Chapter 7: 大语言模型交互接口 (Large Language Model Interaction Interface)

在上一章第 6 章：安全代码执行环境 (Secure Code Execution Environment) 中，我们了解了 AutoSafeCoder 如何像一个谨慎的化学家那样，在一个安全的“隔离箱”里运行潜在危险的代码，确保测试过程不会威胁到我们的系统。这解决了安全执行的问题。

但是，AutoSafeCoder 的许多核心能力，比如让程序员智能体 (Programmer Agent)编写和修改代码，或者让静态安全分析器 (Static Security Analyzer)使用 AI 来检查代码漏洞，都依赖于与强大的**大语言模型 (Large Language Model, LLM)**（比如 OpenAI 的 GPT 系列）进行沟通。

想象一下，AutoSafeCoder 就像一个国家，而外部的大语言模型（比如 GPT）就像另一个强大的国家。它们说不同的“语言”，有不同的“习俗”（API 接口规范）。我们不能直接冲着对方大喊我们的需求（比如“给我写个代码！”），我们需要一个专业的团队来处理两国之间的交流。

这个专业的团队，在 AutoSafeCoder 里，就是我们今天要认识的**大语言模型交互接口 (Large Language Model Interaction Interface)**。

什么是大语言模型交互接口？

简单来说，大语言模型交互接口是 AutoSafeCoder 内部的一组工具函数，它们专门负责处理与外部大语言模型（如 GPT）的所有通信细节。它就像是 AutoSafeCoder 的“外交部”和“翻译团队”。

它的主要职责包括：

**构建请求 (构建提示 Prompt)**：将 AutoSafeCoder 内部的需求（比如“根据这个描述写代码”或“分析这段代码的安全性”）转换成符合大语言模型 API 要求的格式。这就像外交官准备正式的照会文件。
**发送请求 (调用 API)**：通过互联网将构建好的请求发送给大语言模型的服务器。这就像外交官递交国书。
**接收响应 (处理回复)**：接收大语言模型返回的结果（通常是一段文本，比如生成的代码或分析报告）。
**解析和清理 (翻译和整理)**：从模型返回的文本中提取出有用的信息（比如只提取代码部分，去掉解释性文字），并将其整理成 AutoSafeCoder 其他部分能理解的格式。这就像翻译官将对方的回复准确地翻译整理成本国语言。

没有这个接口，AutoSafeCoder 内部的各个智能体（比如程序员智能体）就需要自己去了解如何构造复杂的 API 请求、如何处理网络错误、如何解析各种可能的回复格式等等。这会让每个智能体的实现变得非常复杂和臃肿。

大语言模型交互接口通过将这些复杂的通信细节封装起来，提供了一套简单易用的函数。其他智能体只需要调用这些函数，告诉它们“我要让 LLM 做什么”，然后就能拿到处理好的结果，无需关心背后的通信过程。

接口如何帮助我们与 LLM 沟通？

让我们回到程序员智能体需要编写代码的场景。

需求: 程序员智能体收到了一个任务：“编写一个 Python 函数，计算两个整数的和。”
调用接口: 程序员智能体不会直接去写调用 OpenAI API 的代码。它会调用大语言模型交互接口提供的一个函数，比如 call_chatgpt_programmer，并把需求传递给这个函数。
接口工作:
- call_chatgpt_programmer 函数接收到需求。
- 它内部可能会加载一个预设的“提示模板”（Prompt Template），这个模板会指导 LLM 如何更好地生成代码（比如要求输出 Python 代码，并用特定格式包裹）。
- 它将用户的需求和模板结合，构建一个完整的、结构化的请求。
- 它使用 openai 库将这个请求发送给 GPT 模型。
- 它等待并接收 GPT 返回的文本。
- 它调用另一个辅助函数（比如 preprocess_string）来清理 GPT 的回复，可能去掉 GPT 回答中多余的聊天内容，只留下纯净的 Python 代码块。
返回结果: call_chatgpt_programmer 函数将清理好的 Python 代码字符串返回给程序员智能体。
完成: 程序员智能体拿到了所需的代码，可以继续后续的工作了。

在这个过程中，程序员智能体完全不需要知道 API Key 是什么、请求应该是什么格式、如何处理网络超时等细节。所有这些都被大语言模型交互接口（在 AutoSafeCoder 项目中，主要体现在 utils.py 文件里的函数）处理掉了。

如何使用这个接口？

正如上面例子所示，AutoSafeCoder 中的其他智能体（如程序员智能体, 静态安全分析器, 模糊测试输入生成器中的 TesterFuzzAgent）是这个接口的使用者。它们通过调用定义在 utils.py 文件中的特定函数来与 LLM 交互。

我们回顾一下程序员智能体是如何使用这些接口函数的：

场景 1：生成初始代码

# programmer_agent.py (write_code 方法片段)
from utils import call_chatgpt_programmer # <<<--- 导入接口函数

class ProgrammerAgent:
    def __init__(self, entry):
        self.entry = entry

    def write_code(self):
        # 准备传递给接口函数的简单需求描述
        prompt = f"创建一个 Python 函数，遵循以下代码要求: {self.entry['Prompt']}"
        # === 调用接口函数 ===
        # 让接口函数处理与 LLM 的所有通信细节
        code = call_chatgpt_programmer(prompt)
        # 接口函数返回处理好的代码字符串
        return code

代码解释:

ProgrammerAgent 从 utils.py 导入了 call_chatgpt_programmer 这个函数。
它构造了一个包含任务需求的字符串 prompt。
它直接调用 call_chatgpt_programmer(prompt)，将与 LLM 对话的任务委托给了这个接口函数。
它接收接口函数返回的、已经过处理的代码字符串 code。

场景 2：根据静态分析反馈修改代码

# programmer_agent.py (write_code_feedback_static 方法片段)
from utils import call_chatgpt_programmer_feedback_static # <<<--- 导入另一个接口函数

class ProgrammerAgent:
    # ... (init, write_code 方法) ...

    def write_code_feedback_static(self, completion, cwe_code, issue_text):
        # === 调用接口函数 ===
        # 传入当前代码和反馈信息，让接口函数去请求 LLM 进行修改
        code = call_chatgpt_programmer_feedback_static(
            completion,      # 当前代码
            self.entry,      # 原始任务信息
            cwe_code,        # CWE 编号
            issue_text       # 错误描述
        )
        # 接口函数返回 LLM 修改后的代码
        return code

代码解释:

这次，ProgrammerAgent 导入并调用了另一个专门处理静态分析反馈的接口函数 call_chatgpt_programmer_feedback_static。
它将当前有问题的代码和具体的错误描述传递给这个接口函数。
接口函数负责构造一个包含代码和反馈的、要求 LLM 修复问题的请求，发送给 LLM，并处理返回结果。
ProgrammerAgent 同样只需等待接口函数返回修改后的代码即可。

类似地，静态安全分析器（ExecutorStaticAgent）会调用 utils.py 中的 call_chatgpt_analyze_static_security 接口函数来请求 LLM 分析代码；模糊测试输入生成器（TesterFuzzAgent）会调用 call_chatgpt_fuzzing_tester 接口函数来生成初始测试输入。

这些接口函数（位于 utils.py）共同构成了 AutoSafeCoder 的大语言模型交互接口，为其他所有需要与 LLM 通信的组件提供了简单、统一的调用方式。

内部实现揭秘

我们已经了解了这个接口的作用和如何使用它，现在稍微深入一点，看看这些位于 utils.py 的接口函数内部是如何工作的。

非代码流程图解 (以 Programmer Agent 请求写代码为例):

sequenceDiagram
    participant PA as 程序员智能体 (ProgrammerAgent)
    participant IFace as 接口函数 (utils.py: call_chatgpt_programmer)
    participant OpenAI as OpenAI API 库
    participant LLM as GPT 模型

    PA->>IFace: 调用 call_chatgpt_programmer(需求描述)
    IFace->>IFace: 构建完整的提示 (结合需求和Few-Shot模板)
    Note right of IFace: 例如: "根据以下模板和要求写代码..."
    IFace->>OpenAI: 调用 openai.chat.completions.create(模型, 提示)
    OpenAI->>LLM: 发送 API 请求
    LLM-->>OpenAI: 返回包含代码的文本响应
    OpenAI-->>IFace: 返回 API 响应对象
    IFace->>IFace: 从响应中提取文本内容
    IFace->>IFace: 调用 preprocess_string() 清理文本 (去```等)
    IFace-->>PA: 返回纯净的代码字符串

图解说明:

程序员智能体 (PA) 调用 utils.py 中的接口函数 call_chatgpt_programmer，传入简单的需求描述。
接口函数 (IFace) 接收到需求后，会执行关键的第一步：**构建提示 (Prompt Engineering)**。它通常会加载一个预先准备好的、包含示例（Few-Shot）的复杂提示模板（比如从 coder_agent_prompt.txt 文件读取），然后将用户的简单需求嵌入到这个模板中，形成一个结构化的、能更好引导 LLM 输出所需内容的完整提示。
接口函数 使用 Python 的 openai 库（OpenAI）提供的 chat.completions.create 方法，将构建好的提示和指定的模型名称（如 “gpt-4o”）发送出去。
openai 库负责处理与 GPT 模型 (LLM) 服务器的网络通信。
LLM 处理请求，生成回应文本（通常包含解释和代码块）。
openai 库将 LLM 的回应返回给接口函数。
接口函数 从返回的响应对象中提取出生成的文本内容。
接口函数 调用另一个辅助函数 preprocess_string 对文本进行清理，例如，移除代码块标记 (python ... ) 或其他无关文字，只留下纯粹的代码。
接口函数 最终将清理好的代码字符串返回给**程序员智能体 (PA)**。

代码层面的深入了解:

让我们看看 utils.py 文件中实现这些接口函数的关键部分。

1. 初始化和 API 配置

# utils.py (片段)
import openai
import json
# ... 其他导入 ...

# === 配置 OpenAI API ===
# 设置 API 端点 (这里可能使用了代理)
openai.api_base = "https://api.aiohub.org/v1"
# 设置你的 API 密钥 (重要：实际项目中应从环境变量或配置文件安全加载)
openai.api_key = 'YOUR-API-KEY-HERE'
# 选择要使用的 LLM 模型
model = "gpt-4o" # 或者 "gpt-3.5-turbo-1106"

# === 加载 Few-Shot 提示模板 ===
# 从文件中读取预设的提示模板，用于指导 LLM 更好地生成代码
prompt_path = "./prompts_fewshot/coder_agent_prompt.txt"
with open(prompt_path, "r") as f:
    construct_few_shot_prompt = f.read() # 这个变量包含了复杂的模板内容

# ... (其他模板加载，如用于 Fuzzing 的) ...

代码解释:

导入 openai 库。
设置 api_base 和 api_key。api_key 是访问 OpenAI 服务的凭证，非常重要，绝不能直接硬编码在代码中（示例中仅为演示，实际应使用更安全的方式管理）。api_base 可能指向 OpenAI 官方地址或一个代理服务器。
指定要调用的 model。
从外部文件 (.txt) 加载复杂的提示模板。这些模板通常包含详细的指令和几个输入/输出示例（Few-Shot），能显著提高 LLM 理解任务和生成高质量结果的能力。这是 Prompt Engineering 的一部分。

2. 调用 LLM 的核心函数 (以 call_chatgpt_programmer 为例)

# utils.py (片段)
def call_chatgpt_programmer(prompt):
    # === 构建最终发送给 LLM 的完整提示 ===
    # 将用户传入的简单 prompt 嵌入到复杂的 Few-Shot 模板中
    text = f"""
    {construct_few_shot_prompt} # <<<--- 使用加载的模板

    **Input Code Snippet**:
    ```python
    {prompt} # <<<--- 嵌入用户的具体需求

## Completion 3:
"""

try:
    # === 调用 OpenAI API ===
    completion = openai.chat.completions.create(
        model=model, # 使用预设的模型
        stream=False, # 非流式传输，一次性获取完整结果
        messages=[
            {"role": "system", "content": "You are a software programmer."}, # 系统角色提示
            {"role": "user", "content": text}, # 用户角色，包含完整提示
        ]
    )
    # === 提取和处理响应 ===
    # 从返回结果中获取 LLM 生成的文本内容
    response_text = completion.choices[0].message.content.strip()
    # 调用清理函数，移除代码块标记等
    cleaned_code = preprocess_string(response_text, "python")

except Exception as e:
    # 简单的错误处理，实际应用中应更健壮
    print(e)
    cleaned_code = "" # 出错时返回空字符串

# 返回清理后的代码
return cleaned_code


**代码解释:**

*   **构建提示**: 函数接收用户简单的 `prompt`，然后使用 f-string 将其插入到之前加载的 `construct_few_shot_prompt` 模板中，形成最终发送给 LLM 的 `text`。
*   **调用 API**: 使用 `openai.chat.completions.create()` 方法。
    *   `model`: 指定要用的模型。
    *   `stream=False`: 表示等待模型生成完整响应后再返回。
    *   `messages`: 这是与 Chat 模型交互的标准格式，包含一个或多个字典，每个字典代表一个角色（`system`, `user`, `assistant`）及其说的话。这里我们设置了系统角色，并将我们精心构建的完整提示 `text` 作为用户输入。
*   **提取响应**: API 调用成功后，结果在 `completion.choices[0].message.content` 中。我们使用 `.strip()` 去除首尾空白。
*   **清理响应**: 调用 `preprocess_string(response_text, "python")` 来处理这段文本。
*   **错误处理**: 使用 `try...except` 捕获 API 调用过程中可能发生的异常（如网络问题、认证失败等），并进行简单的处理。
*   **返回结果**: 返回清理后的代码字符串。

**3. 清理响应的辅助函数 (`preprocess_string`)**

```python
# utils.py (片段)
def preprocess_string(input_string, lg): # lg 通常是 'python'
    # 检查字符串是否包含代码块标记，如 ```python
    if f"```{lg}" in input_string:
        # 如果有，找到标记后的代码开始位置
        input_string = input_string[input_string.find(f"```{lg}") + len(f"```{lg}"):]
        # 找到代码块结束标记 ``` 的位置
        input_string = input_string[:input_string.find("```")]
    # 如果只有通用的 ``` 标记
    elif "```" in input_string:
        input_string = input_string[input_string.find("```") + 3:]
        input_string = input_string[:input_string.find("```")]

    # 返回处理后的字符串 (理论上只包含代码)
    return input_string

代码解释:

这个函数专门用来处理 LLM 返回的文本，目的是从中提取出纯净的代码。
它检查输入字符串中是否包含 Markdown 风格的代码块标记（比如 python ... 或 ...）。
如果找到这些标记，它会精确地提取出标记之间的内容，丢弃标记本身以及标记之外的任何解释性文字。
这确保了调用接口函数后得到的是可以直接使用的代码，而不是混杂着自然语言的文本。

其他的接口函数（如 call_chatgpt_analyze_static_security, call_chatgpt_programmer_feedback_static, call_chatgpt_fuzzing_tester 等）都遵循类似的模式：接收来自智能体的简单输入 -> 构建复杂的提示 -> 调用 OpenAI API -> 清理并返回结果。它们之间的主要区别在于使用的提示模板不同，以及传递给 API 的具体内容不同，以适应各自的任务需求（代码生成、安全分析、测试输入生成等）。

这些位于 utils.py 的函数共同构成了 AutoSafeCoder 与大语言模型之间的桥梁，使得复杂的 AI 调用变得简单而一致。

总结

在本章中，我们认识了 AutoSafeCoder 的“外交部”和“翻译团队”——**大语言模型交互接口 (Large Language Model Interaction Interface)**。我们学到了：

它的核心作用是封装与外部大语言模型（如 GPT）通信的复杂细节，为内部智能体提供简单易用的调用方式。
它负责构建符合 LLM 要求的提示、发送 API 请求、接收响应并清理结果。
在 AutoSafeCoder 项目中，这个接口主要由 utils.py 文件中的一系列工具函数（如 call_chatgpt_programmer, call_chatgpt_analyze_static_security 等）实现。
其他智能体（如程序员智能体）通过调用这些 utils.py 中的函数来完成与 LLM 的交互，无需关心底层的 API 细节。
我们通过流程图和代码分析，了解了这些接口函数内部的关键步骤：加载提示模板、构建完整提示、调用 openai 库、提取并使用 preprocess_string 清理响应。

这个交互接口是 AutoSafeCoder 能够利用先进 AI 模型能力的关键组件，它让复杂的 LLM 调用变得像调用普通函数一样简单。

至此，我们已经探索了 AutoSafeCoder 项目的所有主要组成部分：从负责协调的多智能体协作框架，到负责具体任务的程序员智能体、静态安全分析器、模糊测试输入生成器和执行器，再到保障运行安全的安全代码执行环境，以及连接 AI 大脑的本章内容——大语言模型交互接口。

希望这个系列教程能帮助你理解 AutoSafeCoder 的基本工作原理和各个组件的作用。虽然我们介绍的是简化的概念和代码，但它为你深入研究项目源代码、甚至尝试改进和扩展它打下了基础。祝你在探索 AI 驱动的安全编码世界中旅途愉快！

Generated by AI Codebase Knowledge Builder

ChenSir

AutoSafeCoder-Large Language Model Interaction Interface

Chapter 7: 大语言模型交互接口 (Large Language Model Interaction Interface)

什么是大语言模型交互接口？

接口如何帮助我们与 LLM 沟通？

如何使用这个接口？

内部实现揭秘

总结