AI Agent Harness Engineering 自动化测试方案：单元测试、集成测试与场景测试

Python编程之道

77人浏览 · 2026-06-09 23:28:03

Python编程之道 · 2026-06-09 23:28:03 发布

AI Agent Harness Engineering 自动化测试方案：单元测试、集成测试与场景测试

关键词：AI Agent, Harness Engineering, 自动化测试, 单元测试, 集成测试, 场景测试

摘要：在人工智能代理（AI Agent）正逐渐成为软件开发领域的新星，但如何确保这些智能代理可靠、稳定、高效地工作呢？本文将深入浅出地介绍AI Agent Harness Engineering自动化测试方案，通过单元测试、集成测试和场景测试三个维度，全面保障AI Agent的质量。我们会用通俗易懂的语言，像讲故事一样，让你轻松掌握这些复杂的技术概念。

背景介绍

目的和范围

在这个人工智能技术飞速发展的今天，AI Agent（人工智能代理）已经不再是科幻小说里的概念，而是实实在在地走进了我们的生活。从智能客服到自动驾驶，从推荐系统到游戏AI，AI Agent正在改变着我们的世界。但是，就像我们需要确保玩具汽车需要定期保养和维护一样，AI Agent也需要经过严格的测试，才能确保它们能够安全、可靠、高效地为我们服务。

本文的目的就是要向大家介绍一种叫做"Harness Engineering"（ harness可以理解为“驾驭、控制）的自动化测试方案，专门针对AI Agent的测试。我们会从三个层面来讲解：单元测试（测试单个小部件）、集成测试（测试部件组合在一起的效果）和场景测试（测试在真实环境中的表现）。

预期读者

这篇文章适合所有对AI Agent测试感兴趣的朋友们，无论你是刚入门的小白，还是有一定经验的开发者，都能从中学到东西。我们会用最简单的语言，像讲故事一样，把复杂的技术概念讲清楚。

文档结构概述

我们的文章结构就像一次探险之旅：首先，我们会进入一个有趣的故事世界，认识我们的主角——AI Agent；然后，我们会学习一些核心概念，就像拿到探险地图；接着，我们会深入了解测试的原理和方法，就像学习探险技能；然后，我们会动手实践，就像真正开始探险；最后，我们会总结这次探险的收获，展望未来的探险路线。

术语表

核心术语定义

AI Agent（人工智能代理）：就像一个小小的智能机器人，能够感知环境、做出决策、执行任务的软件系统。
Harness Engineering（驾驭工程）：就像给AI Agent设计的一套测试和控制系统，确保它们能按照预期工作。
自动化测试：就像用机器代替人工来测试软件，又快又准。

缩略词列表

AI：Artificial Intelligence（人工智能）
UT：Unit Testing（单元测试）
IT：Integration Testing（集成测试）
ST：Scenario Testing（场景测试）

核心概念与联系

故事引入

想象一下，我们有一个超级英雄团队，每个超级英雄都有自己独特的超能力。有的力大无穷，有的能飞，有的能隐身。但是，这些超级英雄单独行动的时候可能会出问题：力大无穷的英雄可能会不小心把东西弄坏，能飞的英雄可能会迷路，能隐身的英雄可能会忘记自己隐身了吓坏人。

这时候，我们就需要一个"超级英雄训练基地（Harness Engineering），来测试和训练这些超级英雄。首先，我们要单独测试每个超级英雄的能力（单元测试），确保他们能控制好自己的超能力。然后，我们让几个超级英雄一起执行任务（集成测试），看看他们能不能合作。最后，我们模拟真实的危险场景（场景测试），看看整个团队能不能应对各种突发情况。

这就是我们今天要讲的AI Agent Harness Engineering自动化测试方案！AI Agent就像这些超级英雄，而我们的测试方案就是训练基地，确保他们能安全、可靠地为我们服务。

核心概念解释（像给小学生讲故事一样）

核心概念一：什么是AI Agent？

想象一下，你有一个聪明的小机器人助手，它能帮你做很多事情。早上，它能根据天气告诉你该穿什么衣服；你做作业遇到不会的题，它能帮你讲解；你想玩游戏，它能陪你一起玩。这个小机器人助手就是一个AI Agent！

在技术的世界里，AI Agent就是一个能够感知周围环境（比如听你说的话、看你发来的消息）、思考并做出决策（比如决定给你推荐什么书）、然后执行行动（比如帮你搜索资料）的软件系统。

核心概念二：什么是Harness Engineering？

Harness这个词本来是指控制马的缰绳，或者是保护工人的安全带。Harness Engineering就像是给AI Agent设计的缰绳和安全带，既能控制它们，又能保护它们（还有我们！）。

想象一下，你有一只特别聪明但也特别调皮的小狗，你想教它坐下、握手、捡球。你需要用狗绳来控制它，不让它乱跑，还需要用零食来训练它。Harness Engineering就像是AI Agent的狗绳和训练工具，它能帮助我们测试AI Agent，确保它们听话、能干、不出乱子。

核心概念三：什么是自动化测试？

以前，我们测试软件都是靠人工，就像老师批改作业一样，一道题一道题地看，既费时间又容易出错。自动化测试就像是一台神奇的自动批改机，能一下子批改成千上万份作业，又快又准！

对于AI Agent来说，自动化测试就是用程序代替人工来测试AI Agent。我们写好测试程序，让它自动运行，自动检查结果，这样我们就能快速知道AI Agent有没有问题了。

核心概念四：什么是单元测试？

想象一下，你有一个复杂的乐高机器人，由成百上千个小积木块组成。在你把它拼好之前，你会先检查每个积木块是不是完好无损，形状对不对。这就是单元测试！

对于AI Agent来说，单元测试就是测试它的每个小部分（比如能听懂你说话的部分、能思考的部分、能做事的部分）是不是能正常工作。我们把AI Agent拆成一个个小"积木块"，然后一个个测试，确保每个都没问题。

核心概念五：什么是集成测试？

好，现在每个积木块都没问题了，你把它们拼在一起，变成了乐高机器人。这时候你要测试一下，它的胳膊能动，腿能走路，眼睛能看东西，这就是集成测试！

对于AI Agent来说，集成测试就是把那些测试好的小部分组合在一起，测试它们能不能一起工作。比如，能听懂你说话的部分和能思考的部分能不能配合好，能思考的部分和能做事的部分能不能配合好。

核心概念六：什么是场景测试？

乐高机器人拼好了，胳膊腿都能动了，这时候你要让它真正地在你家的客厅里走走，看看它能不能避开障碍物，能不能走到你指定的地方，这就是场景测试！

对于AI Agent来说，场景测试就是模拟真实的使用环境，测试AI Agent能不能完成真实的任务。比如，一个客服AI Agent，我们要测试它能不能处理客户的各种问题，能不能在客户生气的时候好好说话，能不能在复杂的情况下给出正确的答案。

核心概念之间的关系（用小学生能理解的比喻）

现在我们认识了这些超级英雄（AI Agent）、训练基地（Harness Engineering）、自动测试机（自动化测试），还有三种测试方法（单元、集成、场景）。那它们之间是什么关系呢？

**AI Agent和Harness Engineering的关系：就像超级英雄和训练基地的关系。超级英雄需要在训练基地里训练和测试，才能变得更强，才能更好地执行任务。Harness Engineering就是AI Agent的训练基地，帮助我们测试和训练AI Agent。

**自动化测试和三种测试方法的关系：就像自动测试机有三个不同的测试按钮，第一个按钮是测试零件（单元测试），第二个按钮是测试组装好的机器（集成测试），第三个按钮是测试真实使用（场景测试）。这三个按钮配合使用，就能全面测试我们的AI Agent了。

**单元测试、集成测试、场景测试的关系：就像烤蛋糕的过程。单元测试是检查每个食材（面粉、鸡蛋、糖）是不是新鲜；集成测试是把食材混合在一起，看看能不能变成蛋糕糊；场景测试是把蛋糕烤好，尝尝味道好不好看好不好看。只有这三步都做好了，才能做出一个美味的蛋糕！

让我们用一个表格来对比一下这三种测试方法：

测试类型	类比	测试内容	测试目的	测试时机
单元测试	检查每个积木块	单个小功能、小模块	确保每个部分都能正常工作	开发过程中，写完一个小功能就测试
集成测试	检查拼好的机器人	多个模块组合在一起	确保模块之间能配合好	单元测试通过后，模块组合时测试
场景测试	在客厅里试玩机器人	整个系统在真实环境中	确保整个系统能完成真实任务	集成测试通过后，发布前测试

核心概念原理和架构的文本示意图

现在，让我们用文字来画一张图，看看这个AI Agent Harness Engineering自动化测试系统的架构：

想象一下，我们有一个大工厂，这个工厂就是Harness Engineering测试中心。这个中心有三个主要车间：

单元测试车间：这里有很多小工作台，每个工作台上都在测试AI Agent的一个小零件。比如，有一个工作台在测试"耳朵"（语音识别模块），能不能听清各种声音；有一个工作台在测试"大脑"（决策模块），能不能做出正确的决定；还有一个工作台在测试"手"（执行模块），能不能准确地执行任务。
集成测试车间：这里有一些更大的工作台，把测试好的零件组装起来测试。比如，把"耳朵"和"大脑"连起来，看看听到的信息能不能传给大脑；把"大脑"和"手"连起来，看看大脑的命令能不能让手动起来。
场景测试车间：这里就像一个小的真实世界，有各种模拟的场景。比如，对于一个客服AI Agent，这里有模拟的客户提问，有模拟的复杂情况，有模拟的紧急情况。我们把组装好的AI Agent放到这个小世界里，看看它能不能应对各种情况。

在这三个车间的上面，有一个自动化控制中心，它负责指挥这三个车间的工作，自动运行测试，自动收集测试结果，自动生成测试报告。

在这三个车间的旁边，有一个测试数据仓库，里面存放着各种各样的测试数据，比如测试"耳朵"用的各种声音，测试"大脑"用的各种问题，测试场景用的各种模拟情况。

Mermaid 流程图

核心算法原理 & 具体操作步骤

好了，现在我们认识了这些核心概念，接下来让我们深入了解一下这些测试背后的算法原理和具体操作步骤。我们会用Python代码来举例，让大家能更直观地理解。

单元测试的算法原理

单元测试的核心思想就是"隔离测试"。就像我们检查每个积木块一样，我们要把AI Agent的每个小模块隔离出来，单独测试。这就需要用到一些技巧，比如"模拟"（Mock），就像我们给积木块找一个"假的搭档，来测试它能不能和搭档配合得好不好。

单元测试的算法原理可以用一个简单的公式来表示：

$测试结果 = 实际输出 - 预期输出$

如果实际输出和预期输出一样，测试通过；如果不一样，测试失败。

让我们用一个简单的例子来说明。假设我们有一个AI Agent的一个小模块，叫做"加法器"，它的功能是把两个数加起来。我们要测试这个模块是不是能正常工作。

首先，我们要确定预期输出：比如，输入1和2，预期输出是3；输入5和7，预期输出是12；输入-3和-4，预期输出是-7。

然后，我们让这个"加法器"模块实际运行，得到实际输出。

最后，我们比较实际输出和预期输出，如果一样，测试通过；如果不一样，测试失败。

这就是单元测试的基本原理！

集成测试的算法原理

集成测试的核心思想是"接口测试"。就像我们检查拼好的乐高机器人，胳膊和身体连接的地方能不能活动自如一样，我们要测试AI Agent的各个模块之间的接口能不能正常工作，数据能不能在模块之间正常传输。

集成测试的算法原理可以用一个公式来表示：

$集成测试结果 = 模块 A 输出 + 模块 B 输入 + 模块 B 输出 - 预期集成输出$

我们需要确保模块A的输出能正确地作为模块B的输入，然后模块B的输出能符合预期。

让我们继续用上面的例子。假设我们有两个模块，“加法器"和"乘法器”。“加法器"把两个数加起来，然后把结果传给"乘法器”，"乘法器"把这个结果再乘以2。我们要测试这两个模块能不能配合好。

首先，我们确定预期集成输出：比如，输入1和2给"加法器"，"加法器"输出3，然后"乘法器"乘以2得到6，这就是预期集成输出。

然后，我们让这两个模块实际运行，得到实际集成输出。

最后，我们比较实际集成输出和预期集成输出，如果一样，测试通过；如果不一样，测试失败。

这就是集成测试的基本原理！

场景测试的算法原理

场景测试的核心思想是"端到端测试"。就像我们在客厅里试玩乐高机器人，看看它能不能完成整个任务一样，我们要测试AI Agent在真实的使用场景中，能不能从开始到结束，完整地完成任务。

场景测试的算法原理可以用一个公式来表示：

$场景测试结果 = 整个流程的实际结果 - 预期场景结果$

我们需要模拟真实的使用场景，让AI Agent完整地执行任务，然后比较实际结果和预期结果。

让我们用一个客服AI Agent的例子来说明。假设场景是：客户问"今天天气怎么样？"，AI Agent应该先理解客户的问题，然后查询天气数据，最后给出回答。

首先，我们确定预期场景结果：比如，客户问"今天北京天气怎么样？“，AI Agent应该回答"今天北京晴天，温度25度”。

然后，我们模拟这个场景，让AI Agent实际运行，得到实际场景结果。

最后，我们比较实际场景结果和预期场景结果，如果一样，测试通过；如果不一样，测试失败。

这就是场景测试的基本原理！

具体操作步骤（Python代码示例）

现在，让我们用Python代码来实现这三种测试方法。我们会用一个简单的AI Agent例子，这个AI Agent有三个模块：“理解模块”（理解用户的问题）、“回答模块”（根据理解生成回答）、“执行模块”（把回答说出来）。

首先，我们需要安装一个Python的测试框架，叫做pytest，它能帮助我们方便地写测试。

安装命令：

pip install pytest

然后，我们来写我们的AI Agent代码：

# ai_agent.py

class UnderstandingModule:
    """理解模块：理解用户的问题"""
    
    def understand(self, question):
        """理解用户的问题，返回问题类型"""
        if "天气" in question:
            return "天气"
        elif "时间" in question:
            return "时间"
        else:
            return "未知"

class AnsweringModule:
    """回答模块：根据理解生成回答"""
    
    def answer(self, question_type):
        """根据问题类型生成回答"""
        if question_type == "天气":
            return "今天晴天，温度25度"
        elif question_type == "时间":
            return "现在是下午3点"
        else:
            return "抱歉，我不理解你的问题"

class ExecutionModule:
    """执行模块：把回答说出来"""
    
    def execute(self, answer):
        """执行回答，这里我们只是返回"""
        return f"AI Agent说：{answer}"

class AIAgent:
    """整个AI Agent"""
    
    def __init__(self):
        self.understanding = UnderstandingModule()
        self.answering = AnsweringModule()
        self.execution = ExecutionModule()
    
    def run(self, question):
        """运行AI Agent的整个流程"""
        question_type = self.understanding.understand(question)
        answer = self.answering.answer(question_type)
        result = self.execution.execute(answer)
        return result

现在，我们来写单元测试：

# test_unit.py
import pytest
from ai_agent import UnderstandingModule, AnsweringModule, ExecutionModule

class TestUnderstandingModule:
    """测试理解模块"""
    
    def test_understand_weather(self):
        """测试理解天气问题"""
        module = UnderstandingModule()
        result = module.understand("今天天气怎么样？")
        assert result == "天气"
    
    def test_understand_time(self):
        """测试理解时间问题"""
        module = UnderstandingModule()
        result = module.understand("现在几点了？")
        assert result == "时间"
    
    def test_understand_unknown(self):
        """测试理解未知问题"""
        module = UnderstandingModule()
        result = module.understand("你好吗？")
        assert result == "未知"

class TestAnsweringModule:
    """测试回答模块"""
    
    def test_answer_weather(self):
        """测试回答天气问题"""
        module = AnsweringModule()
        result = module.answer("天气")
        assert result == "今天晴天，温度25度"
    
    def test_answer_time(self):
        """测试回答时间问题"""
        module = AnsweringModule()
        result = module.answer("时间")
        assert result == "现在是下午3点"
    
    def test_answer_unknown(self):
        """测试回答未知问题"""
        module = AnsweringModule()
        result = module.answer("未知")
        assert result == "抱歉，我不理解你的问题"

class TestExecutionModule:
    """测试执行模块"""
    
    def test_execute(self):
        """测试执行"""
        module = ExecutionModule()
        result = module.execute("今天晴天，温度25度")
        assert result == "AI Agent说：今天晴天，温度25度"

接下来，我们来写集成测试：

# test_integration.py
import pytest
from ai_agent import UnderstandingModule, AnsweringModule, ExecutionModule

class TestIntegration:
    """集成测试"""
    
    def test_understanding_and_answering(self):
        """测试理解模块和回答模块的集成"""
        understanding = UnderstandingModule()
        answering = AnsweringModule()
        
        # 测试天气问题
        question_type = understanding.understand("今天天气怎么样？")
        answer = answering.answer(question_type)
        assert answer == "今天晴天，温度25度"
        
        # 测试时间问题
        question_type = understanding.understand("现在几点了？")
        answer = answering.answer(question_type)
        assert answer == "现在是下午3点"
    
    def test_answering_and_execution(self):
        """测试回答模块和执行模块的集成"""
        answering = AnsweringModule()
        execution = ExecutionModule()
        
        # 测试天气回答
        answer = answering.answer("天气")
        result = execution.execute(answer)
        assert result == "AI Agent说：今天晴天，温度25度"
    
    def test_all_modules(self):
        """测试所有模块的集成"""
        understanding = UnderstandingModule()
        answering = AnsweringModule()
        execution = ExecutionModule()
        
        # 完整流程
        question_type = understanding.understand("今天天气怎么样？")
        answer = answering.answer(question_type)
        result = execution.execute(answer)
        assert result == "AI Agent说：今天晴天，温度25度"

最后，我们来写场景测试：

# test_scenario.py
import pytest
from ai_agent import AIAgent

class TestScenario:
    """场景测试"""
    
    def test_weather_scenario(self):
        """测试天气场景"""
        agent = AIAgent()
        result = agent.run("今天天气怎么样？")
        assert result == "AI Agent说：今天晴天，温度25度"
    
    def test_time_scenario(self):
        """测试时间场景"""
        agent = AIAgent()
        result = agent.run("现在几点了？")
        assert result == "AI Agent说：现在是下午3点"
    
    def test_unknown_scenario(self):
        """测试未知场景"""
        agent = AIAgent()
        result = agent.run("你好吗？")
        assert result == "AI Agent说：抱歉，我不理解你的问题"
    
    def test_multiple_questions_scenario(self):
        """测试多个问题的场景"""
        agent = AIAgent()
        
        # 第一个问题
        result1 = agent.run("今天天气怎么样？")
        assert result1 == "AI Agent说：今天晴天，温度25度"
        
        # 第二个问题
        result2 = agent.run("现在几点了？")
        assert result2 == "AI Agent说：现在是下午3点"

现在，我们可以运行这些测试了：

# 运行所有测试
pytest

# 运行单元测试
pytest test_unit.py -v

# 运行集成测试
pytest test_integration.py -v

# 运行场景测试
pytest test_scenario.py -v

这样，我们就完成了一个简单的AI Agent Harness Engineering自动化测试方案！

数学模型和公式 & 详细讲解 & 举例说明

在AI Agent的测试中，我们会用到一些数学模型和公式，来帮助我们更准确地测试和评估AI Agent的性能。让我们来学习一些常用的数学模型和公式。

测试覆盖率模型

测试覆盖率是衡量我们测试了多少代码的指标。就像我们检查乐高机器人，我们检查了多少个零件一样。测试覆盖率越高，说明我们测试得越全面。

测试覆盖率的公式是：

$\frac{被测试到的代码行数}{总代码行数} \times 100\%$

比如，我们的AI Agent有100行代码，我们测试了80行，那么覆盖率就是80%。

还有一种测试覆盖率叫做"分支覆盖率"，它衡量的是我们测试了多少个代码分支（比如if-else语句的两个分支）。

分支覆盖率的公式是：

$\frac{被测试到的分支数}{总分支数} \times 100\%$

比如，我们的AI Agent有10个分支，我们测试了8个，那么分支覆盖率就是80%。

缺陷发现率模型

缺陷发现率是衡量我们测试能发现多少缺陷的指标。就像我们检查乐高机器人，能发现多少个有问题的零件一样。缺陷发现率越高，说明我们的测试越有效。

缺陷发现率的公式是：

$\frac{测试发现的缺陷数}{总缺陷数} \times 100\%$

比如，我们的AI Agent有10个缺陷，我们的测试发现了8个，那么缺陷发现率就是80%。

还有一种叫做"缺陷密度"的指标，它衡量的是每千行代码有多少个缺陷。

缺陷密度的公式是：

$\frac{缺陷数}{代码行数/1000}$

比如，我们的AI Agent有1000行代码，有5个缺陷，那么缺陷密度就是5个/千行。

测试有效性模型

测试有效性是衡量我们的测试能有效阻止缺陷发布到生产环境的指标。就像我们检查乐高机器人，能有效阻止有问题的零件被组装成机器人一样。测试有效性越高，说明我们的测试越有用。

测试有效性的公式是：

$\frac{测试发现的缺陷数}{测试发现的缺陷数 + 生产环境发现的缺陷数} \times 100\%$

比如，我们的测试发现了8个缺陷，生产环境发现了2个缺陷，那么测试有效性就是80%。

可靠性模型

可靠性是衡量AI Agent在一定时间内不出现故障的概率的指标。就像我们的乐高机器人，在一定时间内不会坏一样。可靠性越高，说明我们的AI Agent越稳定。

可靠性的公式是（指数分布模型）：

$e^{-\lambda t}$

其中：

$R (t)$ 是在时间 $t$ 内的可靠性
$λ\lambda$ 是故障率（单位时间内的故障次数）
$t$ 是时间
$e$ 是自然常数（约等于2.71828）

比如，我们的AI Agent的故障率是0.01次/小时，那么在100小时内的可靠性是：

$e^{-0.01 \times 100} = e^{-1} \approx 0.3679$

也就是说，在100小时内，我们的AI Agent有36.79%的概率不出现故障。

举例说明

让我们用一个具体的例子来说明这些数学模型和公式。假设我们有一个AI Agent，有1000行代码，10个分支。我们的测试覆盖了800行代码，8个分支。我们的测试发现了8个缺陷，生产环境发现了2个缺陷。我们的AI Agent的故障率是0.01次/小时。

那么：

测试覆盖率 = 800/1000 × 100% = 80%
分支覆盖率 = 8/10 × 100% = 80%
缺陷发现率 = 8/10 × 100% = 80%
缺陷密度 = 10/(1000/1000) = 10个/千行
测试有效性 = 8/(8+2) × 100% = 80%
在100小时内的可靠性 = e^(-0.01×100) ≈ 36.79%
在10小时内的可靠性 = e^(-0.01×10) ≈ 90.48%

这样，我们就能用这些数学模型和公式来全面评估我们的AI Agent和测试方案了！

项目实战：代码实际案例和详细解释说明

好了，现在我们已经学习了核心概念、算法原理、数学模型，接下来让我们来一个真正的项目实战！我们会开发一个简单的AI Agent，然后用Harness Engineering自动化测试方案来测试它。

开发环境搭建

首先，我们需要搭建我们的开发环境。我们需要安装以下工具：

Python 3.8或更高版本
pytest（测试框架）
requests（用于发送HTTP请求）
openai（用于调用OpenAI的API）
python-dotenv（用于管理环境变量）

安装命令：

pip install pytest requests openai python-dotenv

然后，我们需要创建一个项目目录，结构如下：

ai-agent-testing/
├── .env
├── ai_agent/
│   ├── __init__.py
│   ├── understanding.py
│   ├── reasoning.py
│   ├── acting.py
│   └── agent.py
├── tests/
│   ├── __init__.py
│   ├── test_unit.py
│   ├── test_integration.py
│   └── test_scenario.py
└── requirements.txt

在.env文件中，我们需要设置我们的OpenAI API密钥：

OPENAI_API_KEY=your-api-key-here

在requirements.txt文件中，我们列出我们的依赖：

pytest>=7.0.0
requests>=2.28.0
openai>=1.0.0
python-dotenv>=1.0.0

源代码详细实现和代码解读

现在，让我们来写我们的AI Agent代码。我们的AI Agent是一个简单的天气查询助手，它能理解用户的问题，查询天气数据，然后给出回答。

首先，我们来写理解模块（understanding.py）：

# ai_agent/understanding.py
import re

class UnderstandingModule:
    """理解模块：理解用户的问题"""
    
    def __init__(self):
        # 定义一些正则表达式模式
        self.weather_pattern = re.compile(r'天气|气温|温度|下雨|晴天|阴天')
        self.location_pattern = re.compile(r'在(.+?)[？?。！!,，]|(.+?)的天气')
    
    def understand(self, question):
        """
        理解用户的问题
        
        参数:
            question (str): 用户的问题
        
        返回:
            dict: 包含问题类型和位置的字典
        """
        # 判断问题类型
        if self.weather_pattern.search(question):
            question_type = "天气"
        else:
            question_type = "未知"
        
        # 提取位置
        location = None
        location_match = self.location_pattern.search(question)
        if location_match:
            location = location_match.group(1) or location_match.group(2)
            # 清理位置
            location = location.strip()
        
        return {
            "question_type": question_type,
            "location": location
        }

这个理解模块使用正则表达式来理解用户的问题，判断问题类型是不是天气问题，然后提取用户问的是哪个地方的天气。

接下来，我们来写推理模块（reasoning.py）：

# ai_agent/reasoning.py
import requests
import os
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()

class ReasoningModule:
    """推理模块：根据理解查询天气数据"""
    
    def __init__(self):
        # 使用一个免费的天气API
        self.weather_api_url = "https://api.open-meteo.com/v1/forecast"
    
    def reason(self, understanding_result):
        """
        根据理解结果查询天气数据
        
        参数:
            understanding_result (dict): 理解模块的结果
        
        返回:
            dict: 包含天气数据的字典
        """
        question_type = understanding_result["question_type"]
        location = understanding_result["location"]
        
        if question_type != "天气":
            return {
                "success": False,
                "error": "不是天气问题"
            }
        
        if not location:
            return {
                "success": False,
                "error": "没有指定位置"
            }
        
        try:
            # 首先，我们需要获取位置的经纬度（这里简化处理，使用固定的经纬度）
            # 实际应用中，应该使用地理编码API
            # 这里假设北京的经纬度
            lat, lon = 39.9042, 116.4074
            
            # 查询天气数据
            params = {
                "latitude": lat,
                "longitude": lon,
                "current": "temperature_2m,weather_code",
                "timezone": "auto"
            }
            
            response = requests.get(self.weather_api_url, params=params)
            response.raise_for_status()
            
            weather_data = response.json()
            
            # 解析天气数据
            temperature = weather_data["current"]["temperature_2m"]
            weather_code = weather_data["current"]["weather_code"]
            
            # 天气代码转换为天气描述
            weather_desc = self._get_weather_description(weather_code)
            
            return {
                "success": True,
                "location": location,
                "temperature": temperature,
                "weather": weather_desc
            }
            
        except Exception as e:
            return {
                "success": False,
                "error": str(e)
            }
    
    def _get_weather_description(self, weather_code):
        """将天气代码转换为天气描述"""
        weather_codes = {
            0: "晴朗",
            1: "大部晴朗",
            2: "局部多云",
            3: "多云",
            45: "雾",
            48: "雾凇",
            51: "小毛毛雨",
            53: "中毛毛雨",
            55: "大毛毛雨",
            56: "冻毛毛雨",
            57: "大冻毛毛雨",
            61: "小雨",
            63: "中雨",
            65: "大雨",
            66: "冻雨",
            67: "大冻雨",
            71: "小雪",
            73: "中雪",
            75: "大雪",
            77: "雪粒",
            80: "小阵雨",
            81: "中阵雨",
            82: "大阵雨",
            85: "小阵雪",
            86: "大阵雪",
            95: "雷暴",
            96: "雷暴伴小冰雹",
            99: "雷暴伴大冰雹"
        }
        return weather_codes.get(weather_code, "未知天气")

这个推理模块使用Open-Meteo的免费天气API来查询天气数据，然后解析天气数据，转换为我们能理解的天气描述。

接下来，我们来写行动模块（acting.py）：

# ai_agent/acting.py
from openai import OpenAI
import os
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()

class ActingModule:
    """行动模块：根据推理结果生成回答"""
    
    def __init__(self):
        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    
    def act(self, reasoning_result):
        """
        根据推理结果生成回答
        
        参数:
            reasoning_result (dict): 推理模块的结果
        
        返回:
            str: 生成的回答
        """
        if not reasoning_result["success"]:
            return f"抱歉，我无法回答你的问题：{reasoning_result['error']}"
        
        location = reasoning_result["location"]
        temperature = reasoning_result["temperature"]
        weather = reasoning_result["weather"]
        
        # 使用OpenAI的API生成更自然的回答
        try:
            prompt = f"""
            请根据以下天气信息，生成一个友好、自然的回答：
            位置：{location}
            天气：{weather}
            温度：{temperature}摄氏度
            """
            
            response = self.client.chat.completions.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "system", "content": "你是一个友好的天气助手。"},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.7
            )
            
            return response.choices[0].message.content.strip()
        except Exception as e:
            # 如果OpenAI API调用失败，使用简单的回答
            return f"{location}今天的天气是{weather}，温度是{temperature}摄氏度。"

这个行动模块使用OpenAI的API来生成更自然、友好的回答。如果OpenAI API调用失败，它会使用一个简单的回答作为备用。

最后，我们来写整个AI Agent（agent.py）：

# ai_agent/agent.py
from .understanding import UnderstandingModule
from .reasoning import ReasoningModule
from .acting import ActingModule

class WeatherAgent:
    """天气查询AI Agent"""
    
    def __init__(self):
        self.understanding = UnderstandingModule()
        self.reasoning = ReasoningModule()
        self.acting = ActingModule()
    
    def run(self, question):
        """
        运行AI Agent的整个流程
        
        参数:
            question (str): 用户的问题
        
        返回:
            str: AI Agent的回答
        """
        # 理解问题
        understanding_result = self.understanding.understand(question)
        
        # 推理查询
        reasoning_result = self.reasoning.reason(understanding_result)
        
        # 生成回答
        answer = self.acting.act(reasoning_result)
        
        return answer

这个AI Agent把三个模块组合在一起，完成整个天气查询的流程。

代码解读与分析

现在，让我们来解读和分析一下我们的代码。

首先，我们的理解模块使用正则表达式来理解用户的问题。正则表达式是一种强大的文本匹配工具，就像一个超级过滤器，能从一堆文字中找到我们想要的信息。

然后，我们的推理模块使用Open-Meteo的免费天气API来查询天气数据。API就像一个窗口，我们可以通过这个窗口向其他服务请求数据，其他服务会通过这个窗口把数据返回给我们。

接着，我们的行动模块使用OpenAI的API来生成更自然、友好的回答。OpenAI的API就像一个超级作家，能根据我们给的信息，写出流畅自然的文字。

最后，我们的AI Agent把这三个模块组合在一起，就像把三个超级英雄组合成一个团队，一起完成天气查询的任务。

现在，让我们来写我们的测试代码。

首先，单元测试（test_unit.py）：

# tests/test_unit.py
import pytest
from unittest.mock import Mock, patch
from ai_agent.understanding import UnderstandingModule
from ai_agent.reasoning import ReasoningModule
from ai_agent.acting import ActingModule

class TestUnderstandingModule:
    """测试理解模块"""
    
    def setup_method(self):
        self.module = UnderstandingModule()
    
    def test_understand_weather_question(self):
        """测试理解天气问题"""
        result = self.module.understand("今天天气怎么样？")
        assert result["question_type"] == "天气"
    
    def test_understand_weather_with_location(self):
        """测试理解带位置的天气问题"""
        result = self.module.understand("北京今天天气怎么样？")
        assert result["question_type"] == "天气"
        assert result["location"] == "北京"
    
    def test_understand_weather_with_location_2(self):
        """测试理解另一种带位置的天气问题"""
        result = self.module.understand("今天上海的天气怎么样？")
        assert result["question_type"] == "天气"
        assert result["location"] == "上海"
    
    def test_understand_non_weather_question(self):
        """测试理解非天气问题"""
        result = self.module.understand("你好吗？")
        assert result["question_type"] == "未知"
        assert result["location"] is None

class TestReasoningModule:
    """测试推理模块"""
    
    def setup_method(self):
        self.module = ReasoningModule()
    
    def test_reason_non_weather_question(self):
        """测试推理非天气问题"""
        understanding_result = {
            "question_type": "未知",
            "location": None
        }
        result = self.module.reason(understanding_result)
        assert result["success"] is False
        assert "不是天气问题" in result["error"]
    
    def test_reason_no_location(self):
        """测试推理没有位置的天气问题"""
        understanding_result = {
            "question_type": "天气",
            "location": None
        }
        result = self.module.reason(understanding_result)
        assert result["success"] is False
        assert "没有指定位置" in result["error"]
    
    @patch('requests.get')
    def test_reason_success(self, mock_get):
        """测试推理成功的情况"""
        # 模拟API响应
        mock_response = Mock()
        mock_response.json.return_value = {
            "current": {
                "temperature_2m": 25.0,
                "weather_code": 0
            }
        }
        mock_response.raise_for_status.return_value = None
        mock_get.return_value = mock_response
        
        understanding_result = {
            "question_type": "天气",
            "location": "北京"
        }
        result = self.module.reason(understanding_result)
        assert result["success"] is True
        assert result["location"] == "北京"
        assert result["temperature"] == 25.0
        assert result["weather"] == "晴朗"

class TestActingModule:
    """测试行动模块"""
    
    def setup_method(self):
        self.module = ActingModule()
    
    def test_act_failure(self):
        """测试行动失败的情况"""
        reasoning_result = {
            "success": False,
            "error": "测试错误"
        }
        result = self.module.act(reasoning_result)
        assert "测试错误" in result
    
    @patch.object(ActingModule, '_ActingModule__init__')
    def test_act_success_without_openai(self, mock_init):
        """测试行动成功但不使用OpenAI的情况"""
        # 我们直接测试act方法的备用逻辑
        mock_init.return_value = None
        module = ActingModule()
        # 手动设置一些必要的属性
        module.client = None
        
        reasoning_result = {
            "success": True,
            "location": "北京",
            "temperature": 25.0,
            "weather": "晴朗"
        }
        result = module.act(reasoning_result)
        assert "北京" in result
        assert "晴朗" in result
        assert "25.0" in result

在单元测试中，我们使用了patch来模拟一些外部依赖，比如API请求和OpenAI的API。这样我们就能隔离测试每个模块，不依赖外部服务。

接下来，集成测试（test_integration.py）：

# tests/test_integration.py
import pytest
from unittest.mock import patch
from ai_agent.understanding import UnderstandingModule
from ai_agent.reasoning import ReasoningModule
from ai_agent.acting import ActingModule

class TestIntegration:
    """集成测试"""
    
    def test_understanding_and_reasoning(self):
        """测试理解模块和推理模块的集成"""
        understanding = UnderstandingModule()
        reasoning = ReasoningModule()
        
        # 测试天气问题
        understanding_result = understanding.understand("北京今天天气怎么样？")
        assert understanding_result["question_type"] == "天气"
        assert understanding_result["location"] == "北京"
        
        # 注意：这里我们不实际调用API，因为集成测试应该快速
        # 实际项目中，我们可以使用测试环境的API
    
    @patch.object(ActingModule, '_ActingModule__init__')
    def test_reasoning_and_acting(self, mock_init):
        """测试推理模块和行动模块的集成"""
        mock_init.return_value = None
        acting = ActingModule()
        acting.client = None
        
        # 模拟推理结果
        reasoning_result = {
            "success": True,
            "location": "北京",
            "temperature": 25.0,
            "weather": "晴朗"
        }
        
        acting_result = acting.act(reasoning_result)
        assert "北京" in acting_result
        assert "晴朗" in acting_result
    
    def test

AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

KV Cache 到底是什么？一文讲透大模型推理加速原理

AtomGit开源社区

CANN AMCT模型压缩工具链全貌解析：从训练后量化到稀疏剪枝的昇腾NPU部署管线——INT8/INT4混合精度量化策略与精度损耗诊断实录详解报告

AtomGit开源社区

【Agentic RL / 强化学习框架】Miles 项目技术分析---（2）--- 关键技术

的本质是一个适配器模式——它将"Agent 多轮交互"（业务关注点）与"RL 训练数据生产"（基础设施关注点）完全解耦。这条解耦线画在了generate()函数上。线以上是 Agent 开发者的世界——OpenAI API、工具调用、业务逻辑。线以下是 RL 基础设施的世界——Session Server、TITO、token 对齐、loss mask、异常降级。Agent 开发者不需要知道线以下