构建自改进的 Agent RAG系统
在本文中,我们将聚焦于医疗健康领域,这是一个极具挑战性的领域,因为需要根据输入查询或知识库考虑多种可能性,而最终决策权仍掌握在人类手中。包括专家Agent、多维评估、帕累托前沿等。
AgentRAG系统就像一个高维向量空间,每个维度代表一个设计决策,比如提示工程、Agent协调、检索策略等等。手动调整这些维度以找到正确的组合极其困难,而生产中未见过的数据常常会破坏在测试中有效的方法。
更好的方法是让系统学习如何自我优化。一个典型的、能够自我进化的AgentRAG流程遵循如下所示的思考过程:
一个协作的专家Agent团队负责执行任务。它接收一个高层次的概念,并使用其当前的标准操作流程生成一份完整的、多来源的文档。 一个多维评估系统对团队的产出进行评分,衡量其在准确性、可行性、合规性等多个目标上的表现,并生成一个性能向量。 一个性能诊断Agent分析这个向量,像顾问一样识别流程中的主要弱点并追溯其根本原因。 一个SOP架构Agent利用这些见解来更新流程,提出专门设计用于修复已识别弱点的新的流程变体。 每个新版本的SOP都会在团队重复任务时进行测试,每次产出都会再次被评估以生成其自身的性能向量。 系统识别出帕累托前沿——所有已测试SOP中的最佳权衡方案,并将这些优化后的策略呈现给人类决策者,完成进化循环。
我们将构建一个完整的、端到端的、自我改进的AgentRAG流水线,它为RAG系统生成不同的设计模式。
医疗AI的知识基础设施
在开始编写自我进化的AgentRAG系统代码之前,我们需要建立一个合适的知识数据库,以及构建架构所需的必要工具。
一个生产级的RAG系统通常包含一组多样化的数据库,包括敏感的组织数据以及开源数据,以提高检索质量并弥补过时或不完整的信息。这个基础步骤可以说是最关键的……
因为数据源的质量将直接决定我们最终产出的质量。
在本节中,我们将组装这个架构的每个组件。以下是我们要做的:
安装开源栈: 我们将用所有必需的库设置环境,重点关注本地优先、开源优先的方法。 配置安全可观测性: 然后,我们将安全地加载API密钥,并从一开始就配置 LangSmith来跟踪和调试我们复杂的Agent交互。构建本地LLM工坊: 我们将使用 Ollama构建一套不同的开源模型,为特定任务分配特定模型,以优化性能和成本。获取和处理多模态数据: 下载并准备四个真实世界的数据源:来自PubMed的科学文献、来自FDA的监管指南、伦理原则以及一个大规模的结构化临床数据集(MIMIC-III)。 索引知识存储: 最后,我们将把这些原始数据处理成高效的、可搜索的数据库,用于非结构化文本的 FAISS向量存储,以及用于结构化临床数据的DuckDB实例。
安装开源栈
所以,我们的第一步是安装所有必需的Python库。一个可复现的环境是任何严肃项目的基石。我们选择了一套行业标准的开源技术栈,让我们能够完全控制系统。这包括用于核心Agent框架的langchain和langgraph,用于与本地LLM交互的ollama,以及像biopython(用于访问PubMed)和duckdb(用于对临床数据进行高性能分析)这样的专业库。
让我们安装所需的模块……
# 我们使用 pip 的 "quiet" (-q) 和 "upgrade" (-U) 标志来安装所有必需的包。
# - langchain, langgraph 等:这些是我们构建和编排Agent的Agent框架的核心。
# - ollama:这是一个客户端库,允许我们的Python代码与本地运行的Ollama服务器通信。
# - duckdb:一个极快的进程内分析数据库,非常适合处理我们的结构化MIMIC数据,无需繁重的服务器设置。
# - faiss-cpu:Facebook AI 的高效相似性搜索库,它将为我们的RAGAgent提供向量存储能力。
# - sentence-transformers:一个易于使用的库,用于获取最先进的文本嵌入模型。
# - biopython, pypdf, beautifulsoup4:一套强大的工具集,用于下载和解析我们多样化的真实世界数据源。
%pip install -U langchain langgraph langchain_community langchain_openai langchain_core ollama pandas duckdb faiss-cpu sentence-transformers biopython pypdf pydantic lxml html2text beautifulsoup4 matplotlib -qqq
我们将一次性收集项目所需的所有工具和构建材料。每个库都有其特定的作用,从使用langgraph的Agent工作流到使用duckdb的数据分析。
现在我们已经安装了所需的模块,让我们开始逐个初始化它们。
环境配置与导入
我们需要安全地配置我们的环境。将API密钥直接硬编码到笔记本中是一个重大的安全风险,并且会使代码难以共享。
我们将使用一个.env文件来管理我们的密钥,主要是我们的LangSmith API密钥。从一开始就设置好LangSmith对于这种复杂程度的项目来说是必须的,它提供了我们跟踪、调试和理解Agent之间交互所需的深度可观测性。那么,让我们开始吧。
import os
import getpass
from dotenv import load_dotenv
# 这个函数来自 python-dotenv 库,它会搜索 .env 文件并将其中的键值对加载到操作系统的环境变量中,使我们的脚本可以访问它们。
load_dotenv()
# 这是一个关键的检查。我们验证脚本能否从环境中访问到必要的API密钥。
if"LANGCHAIN_API_KEY" not in os.environ or "ENTREZ_EMAIL" not in os.environ:
# 如果缺少密钥,我们打印错误并停止,因为应用程序无法继续运行。
print("Required environment variables not set. Please set them in your .env file or environment.")
else:
# 这条确认信息表明我们的密钥已安全加载,可以使用。
print("Environment variables loaded successfully.")
# 我们显式设置 LangSmith 项目名称。这是一个最佳实践,确保该项目生成的所有跟踪信息在 LangSmith 用户界面中自动分组,便于分析。
os.environ["LANGCHAIN_PROJECT"] = "AI_Clinical_Trials_Architect"
函数 load_dotenv() 充当了敏感凭证和我们代码之间的安全桥梁。它读取 .env 文件(该文件绝不应提交到版本控制系统),并将密钥注入到我们的会话环境中。
从这一刻起,我们使用 LangChain 或 LangGraph 执行的每一个操作都将被自动捕获并发送到我们在 LangSmith 中的项目里。
配置本地LLM
在生产级Agent系统中,“一刀切”的模型策略很少是最优的。一个巨大的、最先进的模型计算成本高昂且速度慢,将其用于每一个简单的任务都是对资源的浪费,尤其是在你自己的GPU上运行。但是,一个小型、快速的模型可能缺乏高风险战略决策所需的深度推理能力。
按回车或点击以全尺寸查看图片
关键在于为你的Agent系统中的每个位置匹配合适的模型。我们将构建一组不同的开源模型,每个模型都因其在特定角色中的优势而被选中,并且全部通过 Ollama 在本地提供服务,以实现隐私性、控制力和成本效益。
我们需要定义一个配置字典来保存我们为每个选定模型创建的客户端。这样我们就可以轻松地更换模型,并将模型管理集中化。
from langchain_community.chat_models import ChatOllama
from langchain_community.embeddings import OllamaEmbeddings
# 这个字典将作为我们所有 LLM 和嵌入模型客户端的中央注册表,或者说“工坊”。
llm_config = {
# 对于 'planner'(规划者),我们使用 Llama 3.1 8B。这是一个现代、能力很强的模型,擅长遵循指令。
# 我们设置 `format='json'` 来利用 Ollama 内置的 JSON 模式,确保这个关键任务能输出可靠的结构化数据。
"planner": ChatOllama(model="llama3.1:8b-instruct", temperature=0.0, format='json'),
# 对于 'drafter'(起草者)和 'sql_coder'(SQL编码者),我们使用 Qwen2 7B。这是一个轻巧快速的模型,
# 非常适合文本生成和代码补全等速度至关重要的任务。
"drafter": ChatOllama(model="qwen2:7b", temperature=0.2),
"sql_coder": ChatOllama(model="qwen2:7b", temperature=0.0),
# 对于 'director'(总监),即最高级别的战略Agent,我们使用强大的 Llama 3 70B 模型。
# 诊断性能并进化系统自身流程这一高风险任务,证明了使用更大、更强大模型的合理性。
"director": ChatOllama(model="llama3:70b", temperature=0.0, format='json'),
# 对于嵌入模型,我们使用 'nomic-embed-text',一个顶级、高效的开源模型。
"embedding_model": OllamaEmbeddings(model="nomic-embed-text")
}
这样我们就创建了 llm_config 字典,它充当了我们所有模型初始化的中心枢纽。通过为不同角色分配不同的模型,我们正在创建一个成本-性能优化的层级结构。
快速灵活型 (7B-8B 模型): planner、drafter和sql_coder角色处理频繁、定义明确的任务。为这些角色使用像Qwen2 7B和Llama 3.1 8B这样的小型模型,可以确保低延迟和高效的资源利用。它们完全有能力遵循指令来生成计划、起草文本或编写SQL。深度战略型 (70B 模型): directorAgent的任务最为复杂,它必须分析多维性能数据并重写整个系统的操作流程。这需要深度推理和对因果关系的理解。对于这个高影响、低频率的任务,我们分配了最强大的资源,即Llama 3 70B模型。
让我们执行这个单元格来初始化客户端并打印它们的配置。
# 打印配置以确认客户端已初始化且参数设置正确。
print("LLM clients configured:")
print(f"Planner ({llm_config['planner'].model}): {llm_config['planner']}")
print(f"Drafter ({llm_config['drafter'].model}): {llm_config['drafter']}")
print(f"SQL Coder ({llm_config['sql_coder'].model}): {llm_config['sql_coder']}")
print(f"Director ({llm_config['director'].model}): {llm_config['director']}")
print(f"Embedding Model ({llm_config['embedding_model'].model}): {llm_config['embedding_model']}")
这是我们将得到的结果:
#### OUTPUT ####
LLM clients configured:
Planner (llama3.1:8b-instruct): ChatOllama(model='llama3.1:8b-instruct', temperature=0.0, format='json')
Drafter (qwen2:7b): ChatOllama(model='qwen2:7b', temperature=0.2)
SQL Coder (qwen2:7b): ChatOllama(model='qwen2:7b', temperature=0.0)
Director (llama3:70b): ChatOllama(model='llama3:70b', temperature=0.0, format='json')
Embedding Model (nomic-embed-text): OllamaEmbeddings(model='nomic-embed-text')
输出确认我们的 ChatOllama 和 OllamaEmbeddings 客户端已成功初始化,并带有各自的模型和参数。现在,我们已经准备好连接到我们的知识存储。
准备知识存储
这是RAG最重要的部分,一个丰富的多模态知识库供其调用。对于像临床试验设计这样的专业任务来说,通用的基于网络的搜索是不够的。我们需要让我们的Agent基于权威的、特定领域的信息。
为了实现这一点,我们现在将通过获取、下载和处理四种不同类型的真实世界数据来构建一个全面的知识库。这种多源方法对于使我们的Agent能够综合信息并产生全面、均衡的输出至关重要。
首先,是一个小而重要的步骤:我们将创建存放下载和处理后的数据的目录。
import os
# 一个字典,用于存放我们不同数据类型的路径。这使我们的文件管理保持干净和集中。
data_paths = {
"base": "./data",
"pubmed": "./data/pubmed_articles",
"fda": "./data/fda_guidelines",
"ethics": "./data/ethical_guidelines",
"mimic": "./data/mimic_db"
}
# 这个循环遍历我们定义的路径,并使用 os.makedirs() 创建任何尚不存在的目录。
# 这可以防止在后续步骤中尝试将文件保存到这些位置时出错。
for path in data_paths.values():
if not os.path.exists(path):
os.makedirs(path)
print(f"Created directory: {path}")
我们确保项目从一开始就拥有一个干净、有序的文件结构。通过预先定义并创建这些目录,我们后续的数据处理函数变得更加健壮,它们可以可靠地将输出保存到正确的位置,而无需先检查目录是否存在。
接下来,我们将从PubMed获取真实的科学文献。这将为我们的Medical ResearcherAgent提供核心知识,使其工作建立在最新的、经过同行评审的科学基础上。
from Bio import Entrez
from Bio import Medline
def download_pubmed_articles(query, max_articles=20):
"""从PubMed获取给定查询的摘要,并将其保存为文本文件。"""
# NCBI API 需要一个电子邮件地址进行身份识别。我们从环境变量中获取。
Entrez.email = os.environ.get("ENTREZ_EMAIL")
print(f"Fetching PubMed articles for query: {query}")
# 步骤1:使用 Entrez.esearch 查找与我们的查询匹配的文章的 PubMed ID (PMID)。
handle = Entrez.esearch(db="pubmed", term=query, retmax=max_articles, sort="relevance")
record = Entrez.read(handle)
id_list = record["IdList"]
print(f"Found {len(id_list)} article IDs.")
print("Downloading articles...")
# 步骤2:使用 Entrez.efetch 检索 PMID 列表的完整记录(MEDLINE格式)。
handle = Entrez.efetch(db="pubmed", id=id_list, rettype="medline", retmode="text")
records = Medline.parse(handle)
count = 0
# 步骤3:遍历检索到的记录,解析它们,并将每个摘要保存到一个文件中。
for i, record in enumerate(records):
pmid = record.get("PMID", "")
title = record.get("TI", "No Title")
abstract = record.get("AB", "No Abstract")
if pmid:
# 我们以 PMID 命名文件,便于参考并避免重复。
filepath = os.path.join(data_paths["pubmed"], f"{pmid}.txt")
with open(filepath, "w") as f:
f.write(f"Title: {title}\n\nAbstract: {abstract}")
print(f"[{i+1}/{len(id_list)}] Fetching PMID: {pmid}... Saved to {filepath}")
count += 1
return count
download_pubmed_articles 函数是我们连接实时科学文献的直接桥梁。这是一个三步流程:
使用 esearch找到相关的文章ID,再用efetch下载完整记录。然后通过一个循环解析并保存关键信息(标题和摘要)到干净的文本文件中。
让我们用与我们用例相关的查询来运行这个函数。
# 我们定义一个特定的布尔查询,以找到与我们试验概念高度相关的文章。
pubmed_query = "(SGLT2 inhibitor) AND (type 2 diabetes) AND (renal impairment)"
num_downloaded = download_pubmed_articles(pubmed_query)
print(f"PubMed download complete. {num_downloaded} articles saved.")
当我们运行上面的代码时,它将开始下载与我们的查询高度相关的PubMed文章。
#### OUTPUT ####
Fetching PubMed articles for query: (SGLT2 inhibitor) AND (type 2 diabetes) AND (renal impairment)
Found 20 article IDs.
Downloading articles...
[1/20] Fetching PMID: 38810260... Saved to ./data/pubmed_articles/38810260.txt
[2/20] Fetching PMID: 38788484... Saved to ./data/pubmed_articles/38788484.txt
...
PubMed download complete. 20 articles saved.
它成功连接到NCBI数据库,执行了我们特定的查询,并下载了20篇相关的科学摘要,将每篇都保存到我们指定的 pubmed_articles 目录中。
现在,我们的 Medical Researcher Agent将拥有一个丰富、最新且领域特定的知识库,确保其发现建立在真实的科学基础之上。
现在,让我们获取我们的 Regulatory Specialist Agent将需要的监管文件。试验设计的一个关键部分是确保符合政府指南。
import requests
from pypdf import PdfReader
import io
def download_and_extract_text_from_pdf(url, output_path):
"""从URL下载PDF,保存它,并将其文本内容提取到单独的 .txt 文件中。"""
print(f"Downloading FDA Guideline: {url}")
try:
# 我们使用 'requests' 库执行 HTTP GET 请求来下载文件。
response = requests.get(url)
response.raise_for_status() # 这是一个好习惯,如果下载失败(例如404错误),将引发异常。
# 我们保存原始的PDF文件,这对于存档目的很有用。
with open(output_path, 'wb') as f:
f.write(response.content)
print(f"Successfully downloaded and saved to {output_path}")
# 然后我们使用 pypdf 直接从内存中的响应读取 PDF 内容。
reader = PdfReader(io.BytesIO(response.content))
text = ""
# 我们遍历 PDF 的每一页并追加提取出的文本。
for page in reader.pages:
text += page.extract_text() + "\n\n"
# 最后,我们将干净的提取文本保存到一个 .txt 文件中。这是我们的 RAG 系统实际会使用的文件。
txt_output_path = os.path.splitext(output_path)[0] + '.txt'
with open(txt_output_path, 'w') as f:
f.write(text)
return True
except requests.exceptions.RequestException as e:
print(f"Error downloading file: {e}")
return False
这个函数 download_and_extract_text_from_pdf 是我们处理PDF文档的工具。它分为两个阶段。
首先,它从FDA网站下载并保存原始的PDF文件。其次,更重要的是,它立即使用 pypdf处理该PDF,提取所有文本内容。然后,它将这个原始文本保存到一个 .txt文件中。这个预处理步骤至关重要,因为它将复杂的PDF格式转换为简单的文本,稍后我们在构建向量存储时,文档加载器可以轻松读取这些文本。
让我们运行这个函数来下载我们的FDA指南文件。
# 这个URL指向一个真实的FDA关于糖尿病药物开发的指南文件。
fda_url = "https://www.fda.gov/media/71185/download"
fda_pdf_path = os.path.join(data_paths["fda"], "fda_diabetes_guidance.pdf")
download_and_extract_text_from_pdf(fda_url, fda_pdf_path)
#### OUTPUT ####
Downloading FDA Guideline: https://www.fda.gov/media/71185/download
Successfully downloaded and saved to ./data/fda_guidelines/fda_diabetes_guidance.pdf
现在我们既有了原始的 fda_diabetes_guidance.pdf 文件,也有了其提取出的文本版本,都在 fda_guidelines 目录中。我们的 Regulatory Specialist Agent现在已经装备了其基础的法律和监管文本。
接下来,我们将为我们的 Ethics Specialist 创建一个精选的文档。虽然我们可以搜索这些信息,但提供一个简洁、权威的核心原则摘要可确保Agent的推理基于最重要的概念。
# 这个多行字符串包含了贝尔蒙报告三大核心原则的精选摘要,
# 贝尔蒙报告是美国人体受试者研究伦理的基础文件。
ethics_content = """
Title: Summary of the Belmont Report Principles for Clinical Research
1. Respect for Persons: This principle requires that individuals be treated as autonomous agents and that persons with diminished autonomy are entitled to protection. This translates to robust informed consent processes. Inclusion/exclusion criteria must not unduly target or coerce vulnerable populations, such as economically disadvantaged individuals, prisoners, or those with severe cognitive impairments, unless the research is directly intended to benefit that population.
2. Beneficence: This principle involves two complementary rules: (1) do not harm and (2) maximize possible benefits and minimize possible harms. The criteria must be designed to select a population that is most likely to benefit and least likely to be harmed by the intervention. The risks to subjects must be reasonable in relation to anticipated benefits.
3. Justice: This principle concerns the fairness of distribution of the burdens and benefits of research. The selection of research subjects must be equitable. Criteria should not be designed to exclude certain groups without a sound scientific or safety-related justification. For example, excluding participants based on race, gender, or socioeconomic status is unjust unless there is a clear rationale related to the drug's mechanism or risk profile.
"""
# 我们定义保存伦理文档的路径。
ethics_path = os.path.join(data_paths["ethics"], "belmont_summary.txt")
# 我们以写入模式打开文件并保存内容。
with open(ethics_path, "w") as f:
f.write(ethics_content)
print(f"Created ethics guideline file: {ethics_path}")
我们为 Ethics Specialist 创建了一个重点突出的文档。我们没有让Agent去筛选整个贝尔蒙报告,而是为其提供了最关键的信息,格式清晰,易于消化。这确保了其分析将保持一致并基于核心原则。
现在是我们最复杂的数据源:来自MIMIC-III的结构化临床数据。这将为我们的 Patient Cohort Analyst 提供真实世界的人群数据,以评估招募的可行性。
import duckdb
import pandas as pd
import os
def load_real_mimic_data():
"""将真实的 MIMIC-III CSV 文件加载到一个持久的 DuckDB 数据库文件中,高效处理庞大的 LABEVENTS 表。"""
print("Attempting to load real MIMIC-III data from local CSVs...")
db_path = os.path.join(data_paths["mimic"], "mimic3_real.db")
csv_dir = os.path.join(data_paths["mimic"], "mimiciii_csvs")
# 定义所需压缩 CSV 文件的路径。
required_files = {
"patients": os.path.join(csv_dir, "PATIENTS.csv.gz"),
"diagnoses": os.path.join(csv_dir, "DIAGNOSES_ICD.csv.gz"),
"labevents": os.path.join(csv_dir, "LABEVENTS.csv.gz"),
}
# 在开始之前,我们检查所有必要的源文件是否存在。
missing_files = [path for path in required_files.values() if not os.path.exists(path)]
if missing_files:
print("ERROR: The following MIMIC-III files were not found:")
for f in missing_files: print(f"- {f}")
print("\nPlease download them as instructed and place them in the correct directory.")
return None
print("Required files found. Proceeding with database creation.")
# 删除任何旧的数据库文件,以确保我们从零开始构建。
if os.path.exists(db_path):
os.remove(db_path)
# 连接到 DuckDB。如果数据库文件不存在,它将被创建。
con = duckdb.connect(db_path)
# 使用 DuckDB 强大的 `read_csv_auto` 直接从 gzip 压缩的 CSV 文件加载数据到 SQL 表中。
print(f"Loading {required_files['patients']} into DuckDB...")
con.execute(f"CREATE TABLE patients AS SELECT SUBJECT_ID, GENDER, DOB, DOD FROM read_csv_auto('{required_files['patients']}')")
print(f"Loading {required_files['diagnoses']} into DuckDB...")
con.execute(f"CREATE TABLE diagnoses_icd AS SELECT SUBJECT_ID, ICD9_CODE FROM read_csv_auto('{required_files['diagnoses']}')")
# LABEVENTS 表非常庞大。为了稳健地处理它,我们使用两阶段流程。
print(f"Loading and processing {required_files['labevents']} (this may take several minutes)...")
# 1. 将数据加载到一个临时的 'staging' 表中,将所有列视为文本 (`all_varchar=True`)。
# 这可以防止因混合数据类型导致的解析错误。我们还会过滤出只关心我们关注的化验项目 ID
# (50912 对应肌酐 Creatinine, 50852 对应糖化血红蛋白 HbA1c),并使用正则表达式确保 VALUENUM 是数字。
con.execute(f"""CREATE TABLE labevents_staging AS
SELECT SUBJECT_ID, ITEMID, VALUENUM
FROM read_csv_auto('{required_files['labevents']}', all_varchar=True)
WHERE ITEMID IN ('50912', '50852') AND VALUENUM IS NOT NULL AND VALUENUM ~ '^[0-9]+(\\.[0-9]+)?$'
""")
# 2. 创建最终的、干净的表,从 staging 表中选择数据,并将列转换为其正确的数值类型。
con.execute("CREATE TABLE labevents AS SELECT SUBJECT_ID, CAST(ITEMID AS INTEGER) AS ITEMID, CAST(VALUENUM AS DOUBLE) AS VALUENUM FROM labevents_staging")
# 3. 删除临时的 staging 表以节省空间。
con.execute("DROP TABLE labevents_staging")
con.close()
return db_path
我们没有尝试使用 pandas 将庞大的 MIMIC-III CSV 文件加载到内存中(这很可能会导致崩溃),而是利用了 DuckDB 直接从磁盘处理数据的能力。对 LABEVENTS 表的两阶段处理是一个关键技术。通过先将数据作为文本加载,在转换为数值类型之前进行过滤,我们处理了数据质量问题,并创建了一个更小、更干净、查询速度更快的最终表。
让我们执行这个函数来构建我们的临床数据库,然后运行一个快速测试来检查结果。
# 执行函数来构建数据库。
db_path = load_real_mimic_data()
# 如果数据库创建成功,则连接并检查模式和样本数据。
if db_path:
print(f"\nReal MIMIC-III database created at: {db_path}")
print("\nTesting database connection and schema...")
con = duckdb.connect(db_path)
print(f"Tables in DB: {con.execute('SHOW TABLES').df()['name'].tolist()}")
print("\nSample of 'patients' table:")
print(con.execute("SELECT * FROM patients LIMIT 5").df())
print("\nSample of 'diagnoses_icd' table:")
print(con.execute("SELECT * FROM diagnoses_icd LIMIT 5").df())
con.close()
我们得到的输出:
#### OUTPUT ####
Attempting to load real MIMIC-III data from local CSVs...
Required files found. Proceeding with database creation.
Loading PATIENTS.csv.gz into DuckDB...
Loading DIAGNOSES_ICD.csv.gz into DuckDB...
Loading and processing LABEVENTS.csv.gz (this may take several minutes)...
Real MIMIC-III database created at: ./data/mimic_db/mimic3_real.db
Testing database connection and schema...
Tables in DB: ['patients', 'diagnoses_icd', 'labevents']
Sample of 'patients' table:
ROW_ID SUBJECT_ID GENDER DOB DOD DOD_HOSP DOD_SSN EXPIRE_FLAG
0 238 250 F 2164-12-27 2198-02-18 2198-02-18 2198-02-18 1
1 239 251 M 2078-02-21 NaN NaN NaN 0
2 240 252 M 2049-06-06 2123-09-01 2123-09-01 2123-09-01 1
3 241 253 F 2081-11-26 NaN NaN NaN 0
4 242 254 F 2028-04-12 NaN NaN NaN 0
Sample of 'diagnoses_icd' table:
ROW_ID SUBJECT_ID HADM_ID SEQ_NUM ICD9_CODE
0 129769 109 172335 1 40301
1 129770 109 172335 2 486
2 129771 109 172335 3 58281
3 129772 109 172335 4 5855
4 129773 109 172335 5 42822
输出确认我们的数据摄取流程已经完成。我们成功地在 ./data/mimic_db/mimic3_real.db 创建了一个持久的 DuckDB SQL 数据库。测试查询显示,核心表(patients、diagnoses_icd、labevents)已使用正确的模式成功加载。
我们的 Patient Cohort Analyst Agent现在可以访问一个高性能、真实世界的临床数据库,其中包含数百万条记录,使其能够提供真正以数据为基础的可行性估计。
最后,让我们将所有非结构化的文本数据索引到可搜索的向量存储中。这将使我们的 RAG Agent能够访问 PubMed、FDA 和伦理文档。
from langchain_community.document_loaders import DirectoryLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_core.documents import Document
def create_vector_store(folder_path: str, embedding_model, store_name: str):
"""从文件夹加载所有 .txt 文件,将它们分块,并创建一个内存中的 FAISS 向量存储。"""
print(f"--- Creating {store_name} Vector Store ---")
# 使用 DirectoryLoader 高效地从指定文件夹加载所有 .txt 文件。
loader = DirectoryLoader(folder_path, glob="**/*.txt", loader_cls=TextLoader, show_progress=True)
documents = loader.load()
if not documents:
print(f"No documents found in {folder_path}, skipping vector store creation.")
return None
# 使用 RecursiveCharacterTextSplitter 将大文档拆分为更小的块,每个块 1000 个字符,重叠 100 个字符。
# 重叠有助于保持块之间的上下文。
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
texts = text_splitter.split_documents(documents)
print(f"Loaded {len(documents)} documents, split into {len(texts)} chunks.")
print("Generating embeddings and indexing into FAISS... (This may take a moment)")
# FAISS.from_documents 是一个便捷函数,它同时处理文本块的嵌入
# 和一步构建高效的 FAISS 索引。
db = FAISS.from_documents(texts, embedding_model)
print(f"{store_name} Vector Store created successfully.")
return db
def create_retrievers(embedding_model):
"""为所有非结构化数据源创建向量存储检索器,并整合所有知识存储。"""
# 为每种类型的文档创建一个单独的、专门的向量存储。
pubmed_db = create_vector_store(data_paths["pubmed"], embedding_model, "PubMed")
fda_db = create_vector_store(data_paths["fda"], embedding_model, "FDA")
ethics_db = create_vector_store(data_paths["ethics"], embedding_model, "Ethics")
# 返回一个包含所有已配置数据访问工具的单一字典。
# 'as_retriever' 方法将向量存储转换为标准的 LangChain 检索器对象。
# 'search_kwargs' 中的 'k' 参数控制一次搜索返回多少个最相关的文档。
return {
"pubmed_retriever": pubmed_db.as_retriever(search_kwargs={"k": 3}) if pubmed_db else None,
"fda_retriever": fda_db.as_retriever(search_kwargs={"k": 3}) if fda_db else None,
"ethics_retriever": ethics_db.as_retriever(search_kwargs={"k": 2}) if ethics_db else None,
"mimic_db_path": db_path # 我们还包括指向结构化 DuckDB 数据库的文件路径。
}
这个 create_vector_store 函数是从文本文件创建 RAG 就绪知识库的方法。它封装了常见的 "加载 -> 拆分 -> 嵌入 -> 索引" 模式。然后 create_retrievers 函数编排这个过程,为我们的每种文档类型创建一个单独的、专门的向量存储。
我们不是使用一个单一的、庞大的向量存储,而是使用更小的、领域特定的存储。这使得我们的Agent能够执行更有针对性、更高效的搜索(例如,Regulatory Specialist 只会查询 fda_retriever)。
让我们运行最后的函数来构建我们完整的一套知识存储。
# 执行函数以创建我们所有的检索器。
knowledge_stores = create_retrievers(llm_config["embedding_model"])
print("\nKnowledge stores and retrievers created successfully.")
# 打印最终的字典以确认所有组件都已就位。
for name, store in knowledge_stores.items():
print(f"{name}: {store}")
#### OUTPUT ####
--- Creating PubMed Vector Store ---
100%|██████████| 20/20 [00:00<00:00, 1102.77it/s]
Loaded 20 documents, split into 35 chunks.
Generating embeddings and indexing into FAISS... (This may take a moment)
Batches: 100%|██████████| 2/2 [00:03<00:00, 1.70s/it]
PubMed Vector Store created successfully.
--- Creating FDA Vector Store ---
100%|██████████| 1/1 [00:00<00:00, 137.95it/s]
Loaded 1 documents, split into 48 chunks.
Generating embeddings and indexing into FAISS... (This may take a moment)
Batches: 100%|██████████| 2/2 [00:04<00:00, 2.08s/it]
FDA Vector Store created successfully.
--- Creating Ethics Vector Store ---
100%|██████████| 1/1 [00:00<00:00, 143.20it/s]
Loaded 1 documents, split into 1 chunks.
Generating embeddings and indexing into FAISS... (This may take a moment)
Batches: 100%|██████████| 1/1 [00:00<00:00, 2.62it/s]
Ethics Vector Store created successfully.
Knowledge stores and retrievers created successfully.
pubmed_retriever: VectorStoreRetriever(tags=['FAISS', 'OllamaEmbeddings'], vectorstore=<...>)
fda_retriever: VectorStoreRetriever(tags=['FAISS', 'OllamaEmbeddings'], vectorstore=<...>)
ethics_retriever: VectorStoreRetriever(tags=['FAISS', 'OllamaEmbeddings'], vectorstore=<...>)
mimic_db_path: ./data/mimic_db/mimic3_real.db
输出确认我们的整个知识库现在已完全组装并投入运行。我们已成功处理了所有非结构化文本源,PubMed、FDA 和伦理文档,将其处理成可搜索的 FAISS 向量存储。
最终的 knowledge_stores 字典是我们完整、集中的数据访问工具存储库。它包含了我们的Agent团队进行研究所需的一切。
随着我们的数据被下载、处理和索引,以及我们的 LLM 配置完成,我们现在可以开始构建我们Agent系统的第一个主要组件:试验设计团队。
构建内部试验设计网络
我们的知识库现在已经准备就绪,接下来就可以构建系统的核心了。这不是一个简单的、线性的RAG链,而是一个使用 LangGraph 构建的协作式多Agent工作流。在这个工作流中,一个由AI专家组成的团队将协同工作,把一个高层次的试验概念转化为一份详细的、基于数据的关键标准文档。
整个架构的行为并非硬编码的。相反,它由一个我们称之为标准操作流程(GuildSOP)的单一动态配置对象来管理。
这个SOP就是我们RAG流水线的“基因组”,而我们的外部循环 “AI研究总监” 将学习如何进化并优化这个基因组。
在本节中,我们将完成以下工作:
定义RAG基因组: 我们将创建 GuildSOPPydantic模型,这是一个结构化的配置,将控制标签架构工作流的各个方面。设计共享工作区: 我们将定义 GuildState,这是我们的Agent分享计划和发现结果的中心空间。构建专家Agent: 我们将把每个专家(规划者、研究员、SQL分析师、综合者)实现为一个独立的Python函数,作为我们图中的一个节点。 编排协作流程: 我们将使用 LangGraph将这些Agent节点连接起来,定义整个团队完整、端到端的工作流。执行完整的测试运行: 我们还将使用我们的基线SOP来调用整个编译好的团队图,观察它的实际运行情况,并生成我们的第一份关键标准文档。
定义团队SOP
首先,我们需要定义将控制整个行为流程的结构。我们将使用一个Pydantic的 BaseModel 来创建我们的 GuildSOP。这是一个关键的设计选择。使用Pydantic能给我们一个类型化、经过验证且自带文档说明的配置对象。
按回车或点击以全尺寸查看图片
这个 GuildSOP 是核心部分,我们外循环的AI总监稍后将对其进行变异和进化。因此,拥有一个严格的模式对于一个稳定的进化过程至关重要。让我们来编写代码。
from pydantic import BaseModel, Field
from typing import Literal
class GuildSOP(BaseModel):
"""试验设计团队的标准操作流程。此对象作为整个RAG工作流的动态配置。"""
# 此字段保存规划Agent的系统提示词,指导其策略。
planner_prompt: str = Field(description="规划Agent的系统提示词。")
# 此参数控制医学研究员检索的文档数量,允许我们调整其搜索广度。
researcher_retriever_k: int = Field(description="医学研究员要检索的文档数量。", default=3)
# 这是最终撰稿人(综合Agent)的系统提示词。
synthesizer_prompt: str = Field(description="关键标准综合Agent的系统提示词。")
# 这允许我们动态更改最终起草阶段使用的模型,在速度和质量之间进行权衡。
synthesizer_model: Literal["qwen2:7b", "llama3.1:8b-instruct"] = Field(description="综合者使用的LLM。", default="qwen2:7b")
# 这些布尔值充当“功能开关”,允许总监打开或关闭整个Agent能力。
use_sql_analyst: bool = Field(description="是否使用患者队列分析师Agent。", default=True)
use_ethics_specialist: bool = Field(description="是否使用伦理专家Agent。", default=True)
GuildSOP 类不仅仅是一个配置文件,它还是一份定义团队当前策略的动态文档。通过暴露关键的参数,如提示词、检索器设置(researcher_retriever_k),甚至包括使用哪些Agent(use_sql_analyst),我们创建了一组策略,我们外循环的AI总监可以操控这些策略来调整整个系统的性能。
我们对 synthesizer_model 使用了 Literal 类型,以确保类型安全,这样总监只能从预定义的有效模型列表中进行选择。
现在我们已经有了SOP的蓝图,让我们创建一个具体的1.0版本实例。这个 baseline_sop 将是我们团队的起点,一个初始的、人工设计的策略,我们的AI总监将负责改进它。
import json
# 我们使用一组默认的基线值来实例化我们的 GuildSOP 类。
baseline_sop = GuildSOP(
# 初始的规划者提示词非常详细,指导Agent其角色、可用的专家以及所需的JSON输出格式。
planner_prompt="""You are a master planner for clinical trial design. Your task is to receive a high-level trial concept and break it down into a structured plan with specific sub-tasks for a team of specialists: a Regulatory Specialist, a Medical Researcher, an Ethics Specialist, and a Patient Cohort Analyst. Output a JSON object with a single key 'plan' containing a list of tasks. Each task must have 'agent', 'task_description', and 'dependencies' keys.""",
# 综合者提示词指导最终撰稿人如何构建输出文档。
synthesizer_prompt="""You are an expert medical writer. Your task is to synthesize the structured findings from all specialist teams into a formal 'Inclusion and Exclusion Criteria' document. Be concise, precise, and adhere strictly to the information provided. Structure your output into two sections: 'Inclusion Criteria' and 'Exclusion Criteria'.""",
# 我们从研究员默认检索3份文档开始。
researcher_retriever_k=3,
# 最初,我们将为综合者使用快速的 qwen2:7b 模型。
synthesizer_model="qwen2:7b",
# 默认情况下,我们将使用所有专家Agent。
use_sql_analyst=True,
use_ethics_specialist=True
)
我们编写的提示词具有高度针对性,旨在让LLM产生可靠、结构化的行为。这个基线代表了我们对于一个有效策略的最佳初始猜测。这个SOP的性能将作为基准,我们的AI总监将努力超越它。
让我们运行这段代码来创建我们的基线对象,并将其打印出来以供检查。
print("Baseline GuildSOP (v1.0):")
# 我们使用 .dict() 将 Pydantic 模型转换为字典,并用 json.dumps 进行清晰打印。
print(json.dumps(baseline_sop.dict(), indent=4))
当我们运行上面的代码时,会得到以下结果:
#### OUTPUT ####
Baseline GuildSOP (v1.0):
{
"planner_prompt": "You are a master planner for clinical trial design...",
"researcher_retriever_k": 3,
"synthesizer_prompt": "You are an expert medical writer...",
"synthesizer_model": "qwen2:7b",
"use_sql_analyst": true,
"use_ethics_specialist": true
}
输出显示了我们已完全实例化的基线SOP,形式为清晰的JSON对象。我们可以看到所有配置参数,它们将指导我们团队的首次运行。
例如,planner_prompt 清晰地勾勒了预期的输出,我们可以看到 researcher_retriever_k 被设置为 3。如果之后我们的系统因上下文不足而遇到困难,我们的AI总监可以学习增加这个值。这个对象是我们Agent流程的“源代码”,而我们刚刚创建了它的第一个版本。
定义专家Agent
现在我们有了规则手册(即SOP),我们需要定义Agent本身。在 LangGraph 中,Agent被表示为节点,它们其实就是一些Python函数,接收当前图状态作为输入,并返回对该状态的更新。
首先,我们必须定义该状态的结构。这个 GuildState 将是我们所有Agent用于协作的共享工作台或白板。它将包含初始请求、规划者生成的计划、从每个专家收集的发现结果,以及最终输出。
from typing import List, Dict, Any, Optional
from langchain_core.pydantic_v1 import BaseModel
from typing_extensions import TypedDict
# 我们首先定义一个用于单个Agent输出的结构。
# 这确保了每个Agent的发现结果都以一致的方式打包,并带有清晰的归属。
class AgentOutput(BaseModel):
"""每个Agent发现结果的结构化输出。"""
agent_name: str
findings: Any
# 现在我们定义整个团队工作流的主要状态。
class GuildState(TypedDict):
"""试验设计团队工作流的状态,在节点之间传递。"""
initial_request: str # 用户最初的高层次试验概念。
plan: Optional[Dict[str, Any]] # 规划者生成的结构化计划。
agent_outputs: List[AgentOutput] # 一个累积的列表,存放每个专家的发现结果。
final_criteria: Optional[str] # 最终的、综合后的文档。
sop: GuildSOP # 本次运行的动态SOP。
AgentOutput 类确保了当专家完成工作时,他们的发现结果会被整洁地打包并贴上标签。GuildStateTypedDict 是我们共享内存的主蓝图。它是“工作台”,plan 在上面铺开,agent_outputs 像拼图碎片一样被收集起来,final_criteria 最终被组装完成。
至关重要的是,sop 本身也是状态的一部分。这意味着我们可以在每次运行图时注入不同的SOP,从而允许我们的外循环只需更改初始输入中的这一个对象,就能测试不同的策略。
现在,让我们构建我们的第一个Agent:规划者。这个Agent是团队工作的入口点。它接收用户的高层次请求,并在SOP中 planner_prompt 的指导下,为其他专家创建一个结构化的、循序渐进的计划。
def planner_agent(state: GuildState) -> GuildState:
"""接收初始请求,并为专家Agent创建结构化计划。"""
print("--- EXECUTING PLANNER AGENT ---")
# 从状态中获取当前的SOP。这使其行为变得动态。
sop = state['sop']
# 配置 'planner' LLM,使其输出符合 {'plan': []} 模式的JSON。
planner_llm = llm_config['planner'].with_structured_output(schema={"plan": []})
# 通过结合来自SOP的通用提示词和本次运行的特定试验概念来构建完整的提示词。
prompt = f"{sop.planner_prompt}\n\nTrial Concept: '{state['initial_request']}'"
print(f"Planner Prompt:\n{prompt}")
# 调用 LLM 来生成计划。
response = planner_llm.invoke(prompt)
print(f"Generated Plan:\n{json.dumps(response, indent=2)}")
# 返回状态的更新,添加新生成的计划。
return {**state, "plan": response}
它从状态中传入的 sop 对象里读取自己的指令(planner_prompt)。然后,它使用 .with_structured_output() 方法来强制LLM返回一个有效的JSON计划。这是一个非常稳健的模式,避免了手动解析自然语言输出的不确定性。该函数最后返回更新后的状态,现在其中包含了将指导后续Agent的 plan。
我们现在需要构建将执行其计划的专家Agent。为了避免编写重复的代码,我们将首先为我们所有基于RAG的专家(医学研究员、法规专家和伦理专家)创建一个通用的、可复用的函数。
def retrieval_agent(task_description: str, state: GuildState, retriever_name: str, agent_name: str) -> AgentOutput:
"""一个通用的Agent函数,根据任务描述从指定的向量存储中执行检索。"""
print(f"--- EXECUTING {agent_name.upper()} ---")
print(f"Task: {task_description}")
# 从全局的 'knowledge_stores' 字典中选择正确的检索器。
retriever = knowledge_stores[retriever_name]
# 这是一个关键的动态特性:如果Agent是医学研究员,
# 我们使用当前SOP中的值来覆盖其 'k' 值(检索文档数量)。
if agent_name == "Medical Researcher":
retriever.search_kwargs['k'] = state['sop'].researcher_retriever_k
print(f"Using k={state['sop'].researcher_retriever_k} for retrieval.")
# 使用任务描述调用检索器来查找相关文档。
retrieved_docs = retriever.invoke(task_description)
# 将发现结果格式化为一个清晰的字符串,并为可追溯性包含每个文档的来源。
findings = "\n\n---\n\n".join([f"Source: {doc.metadata.get('source', 'N/A')}\n\n{doc.page_content}"for doc in retrieved_docs])
print(f"Retrieved {len(retrieved_docs)} documents.")
print(f"Sample Finding:\n{findings[:500]}...")
# 以我们标准化的 AgentOutput 格式返回发现结果。
return AgentOutput(agent_name=agent_name, findings=findings)
retrieval_agent 函数是一个用于创建RAG专家的可复用组件。我们没有为每个研究员编写单独的函数,而是创建了一个单一的、可配置的Agent。它以 retriever_name 作为参数,并动态选择正确的知识库(PubMed、FDA等)进行查询。最重要的特性是它与 GuildSOP 的交互方式。
它会专门检查自己是否扮演医学研究员的角色,如果是,则根据 state['sop'].researcher_retriever_k 的值调整其检索参数 k。这使得文献检索的详尽程度成为一个动态可调的参数,我们的AI总监可以对其进行进化。
现在,让我们构建我们技术上最复杂的专家:患者队列分析师。这个Agent将弥合非结构化RAG和结构化数据分析之间的差距。它将接收自然语言请求,使用LLM将其翻译成有效的SQL查询,然后针对我们的MIMIC-III数据DuckDB数据库执行该查询,以提供基于数据的可行性估计。
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
def patient_cohort_analyst(task_description: str, state: GuildState) -> AgentOutput:
"""通过针对MIMIC数据库生成并执行SQL查询来估计队列规模。"""
print("--- EXECUTING PATIENT COHORT ANALYST ---")
# 这是一个功能开关。我们首先检查SOP,看这个Agent是否应该运行。
if not state['sop'].use_sql_analyst:
print("SQL Analyst skipped as per SOP.")
return AgentOutput(agent_name="Patient Cohort Analyst", findings="Analysis skipped as per SOP.")
# 为了让LLM写出正确的SQL,它需要知道数据库的模式。
# 我们连接到DuckDB,查询 information_schema 以获取表和列的名称。
con = duckdb.connect(knowledge_stores['mimic_db_path'])
schema_query = """
SELECT table_name, column_name, data_type
FROM information_schema.columns
WHERE table_schema = 'main' ORDER BY table_name, column_name;
"""
schema = con.execute(schema_query).df()
con.close()
# 我们为编写SQL的LLM创建了一个非常详细的提示词。
# 它包含了模式,而且至关重要的是,包含了关于如何将医学概念映射到ICD9代码或实验室值的具体说明。
sql_generation_prompt = ChatPromptTemplate.from_messages([
("system", f"You are an expert SQL writer specializing in DuckDB. Your task is to write a single, valid SQL query to count unique patients based on a request. The database contains MIMIC-III patient data with the following schema:\n{schema.to_string()}\n\nIMPORTANT: All column names in your query MUST be uppercase (e.g., SELECT SUBJECT_ID, ICD9_CODE...).\n\nKey Mappings:\n- T2DM (Type 2 Diabetes) corresponds to ICD9_CODE '25000'.\n- Moderate renal impairment can be estimated by a creatinine lab value (ITEMID 50912) where VALUENUM is between 1.5 and 3.0.\n- Uncontrolled T2D can be estimated by an HbA1c lab value (ITEMID 50852) where VALUENUM is greater than 8.0."),
("human", "Please write a SQL query to count the number of unique patients who meet the following criteria: {task}")
])
# 我们创建一个简单的链来生成SQL查询。
sql_chain = sql_generation_prompt | llm_config['sql_coder'] | StrOutputParser()
print(f"Generating SQL for task: {task_description}")
sql_query = sql_chain.invoke({"task": task_description})
# LLM可能会将查询包装在markdown中,所以我们将其清理干净。
sql_query = sql_query.strip().replace("```sql", "").replace("```", "")
print(f"Generated SQL Query:\n{sql_query}")
try:
# 现在我们针对真实的DuckDB数据库执行生成的查询。
con = duckdb.connect(knowledge_stores['mimic_db_path'])
result = con.execute(sql_query).fetchone()
patient_count = result[0] if result else 0
con.close()
# 我们打包发现结果,包括查询本身,以保证透明度。
findings = f"Generated SQL Query:\n{sql_query}\n\nEstimated eligible patient count from the database: {patient_count}."
print(f"Query executed successfully. Estimated patient count: {patient_count}")
except Exception as e:
# 如果SQL无效或查询失败,我们会优雅地处理错误。
findings = f"Error executing SQL query: {e}. Defaulting to a count of 0."
print(f"Error during query execution: {e}")
return AgentOutput(agent_name="Patient Cohort Analyst", findings=findings)
patient_cohort_analyst 是我们最先进的专家。它在单个函数中就是一个完整的文本到SQLAgent。这里的提示词工程是最关键的部分。通过向LLM提供精确的数据库模式和关键映射(例如,“T2DM”如何转换为 ICD9_CODE '25000'),我们为其提供了生成正确且可执行查询所需的精确上下文。
try...except 块我认为也很重要,这就是我在这里尝试使用它的原因,因为它通过捕获来自LLM的潜在SQL错误,防止它们导致整个工作流崩溃,从而使Agent更加健壮。
定义完我们所有收集数据的专家后,我们需要系统中的最后一个Agent:关键标准综合者。这个Agent的角色是充当主撰稿人。它将从所有其他专家那里收集来的发现结果编织成一份单一的、连贯的、格式正式的文件。
def criteria_synthesizer(state: GuildState) -> GuildState:
"""将所有专家Agent的结构化发现结果综合成最终的关键标准文档。"""
print("--- EXECUTING CRITERIA SYNTHESIZER ---")
# 从状态中获取当前的SOP。
sop = state['sop']
# 根据SOP动态选择综合者模型。这允许总监尝试不同的模型。
drafter_llm = ChatOllama(model=sop.synthesizer_model, temperature=0.2)
# 我们将前面步骤中的所有发现结果合并成一个单一的、大的上下文字符串。
# 每个Agent的发现结果都被清晰地分隔开。
context = "\n\n---\n\n".join([f"**{out.agent_name} Findings:**\n{out.findings}"for out in state['agent_outputs']])
# 构建最终的提示词,结合来自SOP的指令和完整的发现结果上下文。
prompt = f"{sop.synthesizer_prompt}\n\n**Context from Specialist Teams:**\n{context}"
print(f"Synthesizer is using model '{sop.synthesizer_model}'.")
# 调用起草LLM来生成最终文档。
response = drafter_llm.invoke(prompt)
print("Final criteria generated.")
# 返回状态的最终更新,填充 'final_criteria' 字段。
return {**state, "final_criteria": response.content}
它将状态中所有的 agent_outputs 聚合到一个全面的“简报包” 中。一个关键特性是其动态模型选择:drafter_llm = ChatOllama(model=sop.synthesizer_model, ...)。这意味着我们的AI总监可以进化SOP,如果它确定最终草案的质量是一个关键弱点,就可以将综合者切换到一个更强大的模型(如 llama3.1:8b-instruct)。这使得起草速度和质量之间的权衡成为一个可进化的参数。
使用 LangGraph 编排团队工作流
现在我们已经定义了所有单个的Agent节点,我们可以使用 LangGraph 将它们连接成一个协作工作流。我们将定义一个图,首先调用规划者,然后并行执行所有专家任务,最后将收集到的发现结果传递给综合者。
首先,我们需要一个特殊的“执行节点”,负责根据生成的计划调用我们的专家Agent。
from langgraph.graph import StateGraph, END
def specialist_execution_node(state: GuildState) -> GuildState:
"""此节点充当调度器,执行计划中定义的所有专家任务。"""
plan_tasks = state['plan']['plan']
outputs = []
# 我们循环处理规划者生成的计划中的每个任务。
for task in plan_tasks:
agent_name = task['agent']
task_desc = task['task_description']
# 这是我们的路由逻辑。根据任务中的 'agent' 名称,我们调用相应的函数。
if"Regulatory"in agent_name:
output = retrieval_agent(task_desc, state, "fda_retriever", "Regulatory Specialist")
elif"Medical"in agent_name:
output = retrieval_agent(task_desc, state, "pubmed_retriever", "Medical Researcher")
elif"Ethics"in agent_name and state['sop'].use_ethics_specialist:
# 我们尊重来自SOP的 'use_ethics_specialist' 功能开关。
output = retrieval_agent(task_desc, state, "ethics_retriever", "Ethics Specialist")
elif"Cohort"in agent_name:
output = patient_cohort_analyst(task_desc, state)
else:
# 如果Agent被禁用或无法识别,我们简单地跳过。
continue
outputs.append(output)
# 我们返回更新后的状态,其中包含所有收集到的Agent输出列表。
return {**state, "agent_outputs": outputs}
specialist_execution_node 从 GuildState 中获取 plan,并编排所有专家任务的执行。简单的 if/elif 块充当路由器,将每个任务分派给正确的Agent函数(我们的通用 retrieval_agent 或专门的 patient_cohort_analyst)。
这个节点也展示了我们SOP功能开关的强大之处:它在运行Agent之前显式检查 state['sop'].use_ethics_specialist,允许AI总监动态地启用或禁用某些能力。
现在,我们终于可以构建并编译图本身了。
# 我们初始化一个新的 StateGraph,并告诉它使用我们的 GuildState 作为其模式。
workflow = StateGraph(GuildState)
# 我们将三个主要的功能单元作为节点添加到图中。
workflow.add_node("planner", planner_agent)
workflow.add_node("execute_specialists", specialist_execution_node)
workflow.add_node("synthesizer", criteria_synthesizer)
# 我们定义图的控制流。
# 入口点是 'planner'。
workflow.set_entry_point("planner")
# 规划器运行后,图将进入 'execute_specialists' 节点。
workflow.add_edge("planner", "execute_specialists")
# 所有专家都运行完毕后,他们的输出被传递给 'synthesizer'。
workflow.add_edge("execute_specialists", "synthesizer")
# 综合器运行后,图终止。
workflow.add_edge("synthesizer", END)
# compile() 方法将我们的抽象图定义转换为一个可运行的对象。
guild_graph = workflow.compile()
print("Graph compiled successfully.")
现在我们组装好了最终的工作流。我们将三个关键节点 planner、execute_specialists 和 synthesizer 添加到图中。然后,我们使用 .add_edge() 定义了一个简单的、线性的控制流:规划 -> 执行 -> 综合。我使用的 compile() 方法是最后一步,将这个流程转换成一个完全可操作的 guild_graph 对象,随时可以调用。
让我们运行这段代码来编译图。我们还可以选择将其可视化,以查看我们构建的结构。
try:
from IPython.display import Image
# 这行代码将生成图的PNG图像。需要安装 graphviz。
# display(Image(guild_graph.get_graph().draw_png()))
except ImportError:
print("Could not import pygraphviz. Install it to visualize the graph.")
这是我们得到的图:
输出确认我们的 LangGraph 工作流已成功编译。我们现在有了一个可运行的 guild_graph 对象。我们已经成功构建了系统的“内循环”。它现在是一个功能齐全、可配置、多Agent的RAG流水线。
团队图的完整测试运行
图已完全编译完毕,是时候看看它的实际运行效果了。我们将使用我们的 baseline_sop 和一个现实的试验概念进行一次完整的、端到端的测试运行。这次测试将验证我们所有的Agent、数据存储和编排逻辑是否能够协同工作。
它还将产生我们的第一个“基线”输出,这将是后续部分中评估和进化循环的输入。
# 这是我们的高层次请求,是整个工作流的初始火花。
test_request = "Draft inclusion/exclusion criteria for a Phase II trial of 'Sotagliflozin', a novel SGLT2 inhibitor, for adults with uncontrolled Type 2 Diabetes (HbA1c > 8.0%) and moderate chronic kidney disease (CKD Stage 3)."
print("Running the full Guild graph with baseline SOP v1.0...")
# 我们为图准备初始状态,提供请求和我们的基线SOP。
graph_input = {
"initial_request": test_request,
"sop": baseline_sop
}
# 我们使用初始状态调用编译好的图。LangGraph 现在将执行完整的工作流。
final_result = guild_graph.invoke(graph_input)
# 图完成后,我们打印最终的综合输出。
print("\nFinal Guild Output:")
print("---------------------")
print(final_result['final_criteria'])
一旦我们运行这段代码,guild_graph.invoke(graph_input) 调用就会启动整个事件链。在幕后,LangGraph 将:
将 graph_input传递给我们的planner_agent。将规划者的输出和更新后的状态传递给 specialist_execution_node。执行节点将依次调用我们所有的专家。 最后,现在充满了发现结果的状态将被传递给 criteria_synthesizer以生成最终文档。
让我们运行它,并观察每个Agent执行时的详细日志。
#### OUTPUT ####
Running the full Guild graph with baseline SOP v1.0...
# --- EXECUTING PLANNER AGENT ---
Generated Plan:
{
"plan": [
{ "agent": "Regulatory Specialist", "task_description": "Identify FDA guidelines for clinical trials...", "dependencies": [] },
{ "agent": "Medical Researcher", "task_description": "Review recent clinical trials and literature...", "dependencies": [] },
{ "agent": "Ethics Specialist", "task_description": "Assess ethical considerations for enrolling patients...", "dependencies": [] },
{ "agent": "Patient Cohort Analyst", "task_description": "Estimate the number of adult patients with...", "dependencies": ["Medical Researcher"] }
]
}
# --- EXECUTING REGULATORY SPECIALIST ---
Retrieved 3 documents.
...
# --- EXECUTING MEDICAL RESEARCHER ---
Using k=3 for retrieval.
Retrieved 3 documents.
...
# --- EXECUTING ETHICS SPECIALIST ---
Retrieved 2 documents.
...
# --- EXECUTING PATIENT COHORT ANALYST ---
Generated SQL Query:
SELECT COUNT(DISTINCT p.subject_id)
FROM patients p ...
Query executed successfully. Estimated patient count: 59
# --- EXECUTING CRITERIA SYNTHESIZER ---
Synthesizer is using model 'qwen2:7b'.
Final criteria generated.
# Final Guild Output:
---------------------
**Inclusion Criteria:**
1. Male or female adults, age 18 years or older.
2. Diagnosis of Type 2 Diabetes Mellitus (T2DM).
3. Uncontrolled T2DM, defined as a Hemoglobin A1c (HbA1c) value > 8.0% at screening.
...
**Exclusion Criteria:**
1. Diagnosis of Type 1 Diabetes Mellitus.
2. History of severe hypoglycemia within the past 6 months.
...
我们可以看到我们团队协作过程的逐步跟踪。我们看到规划者创建了一个逻辑计划,每个专家通过访问正确的知识库(队列分析师甚至生成并运行了一个复杂的SQL查询)来执行其任务,最后,综合者将所有发现结果组装成一份结构良好的文档。
我们现在已经使用真实世界的数据源构建并成功测试了一个完整的多AgentRAG流水线。它接收一个高层次的概念,并生成一份详细的、多源的草案。下一个,也是最重要的部分,是构建评估和改进这个团队的整个系统。
多维评估系统
一个自我改进的系统,其优劣取决于它衡量自身性能的能力。我们已经构建了一个能够生成详细文档的系统,但如何判断这份文档的质量好坏?更重要的是,我们的AI研究总监如何学会让它变得更好?
为此,我们需要超越像“准确率”这样单一的、单分数的指标。临床试验方案的质量是多维度的。现在,我们将构建一套复杂的评估套件,用来衡量团队输出在我们一开始就确定的五个相互竞争的维度上的表现。这套评估体系将提供丰富的、多维度的反馈信号,这是我们进化外循环的生命线。
在本节中,我们将完成以下工作:
实现 LLM 作为评判官: 我们将使用我们最强大的模型(llama3:70b)构建三个独立的评判官,分别对科学严谨性、法规合规性和伦理合理性这些定性方面进行专家级评估。 创建程序化评估器: 我们将编写两个快速、可靠且客观的程序化函数,用于对招募可行性和操作简洁性这两个定量方面进行评分。 构建聚合评估器: 将以上五个独立的评估器封装到一个主函数中,该函数接收我们团队的最终输出,并生成一个5维性能向量,供我们的AI总监做决策时使用。
为每个参数构建自定义评估器
我们将把五个评估器分别定义为独立的、专门的函数。这种方法允许我们独立地为每个质量维度微调评估逻辑。
首先,一个小工具:我们将定义一个Pydantic模型,以确保我们的LLM评判官的输出始终是结构化的,同时包含数值评分和文本解释。
from langchain_core.pydantic_v1 import BaseModel, Field
class GradedScore(BaseModel):
"""一个Pydantic模型,用于结构化我们的LLM-as-a-Judge评估器的输出。"""
# 分数必须是0.0到1.0之间的浮点数。
score: float = Field(description="一个从0.0到1.0的分数")
# 推理部分为分数提供了定性依据,这对于调试非常有价值。
reasoning: str = Field(description="对分数的简要解释。")
GradedScore 类是一个简单的工程实践。通过强制我们的评估器LLM以这种特定的JSON格式返回反馈,我们使结果可靠且易于解析。现在我们可以确信每次都能收到一个数值评分和一个推理字符串,这使得整个评估和进化系统更加健壮。
现在,让我们构建我们的第一个LLM评判官,专注于科学严谨性。
from langchain_core.prompts import ChatPromptTemplate
# 评估器 1: 科学严谨性 (LLM 作为评判官)
def scientific_rigor_evaluator(generated_criteria: str, pubmed_context: str) -> GradedScore:
"""评估生成的标准是否由提供的文献提供了科学依据。"""
# 我们使用最强大的 'director' 模型来完成这个细致的评估任务。
# .with_structured_output(GradedScore) 指示 LLM 根据我们的 Pydantic 模型格式化其响应。
evaluator_llm = llm_config['director'].with_structured_output(GradedScore)
# 提示词赋予 LLM 一个特定的角色(“临床科学家专家”)和一个清晰的任务。
prompt = ChatPromptTemplate.from_messages([
("system", "你是一位临床科学家专家。请根据提供的科学文献评估一组临床试验标准。1.0分表示标准与文献完全一致并得到充分论证。0.0分表示标准与文献相矛盾或完全忽略文献。"),
# 我们同时提供待评估的标准和作为评判依据的证据。
("human", "评估以下标准:\n\n**生成的标准:**\n{criteria}\n\n**支持性科学背景:**\n{context}")
])
# 我们创建一个简单的 LangChain 表达式语言(LCEL)链。
chain = prompt | evaluator_llm
# 我们使用生成的标准和医学研究员检索到的上下文来调用链。
return chain.invoke({"criteria": generated_criteria, "context": pubmed_context})
scientific_rigor_evaluator 函数是我们的第一个专家评判官。它接收最终生成的 generated_criteria 和医学研究员Agent找到的特定 pubmed_context。通过将两者都提供给评估器LLM,我们是在提出一个非常具体的问题:“这个输出是否以这些证据为基础?”这是我们对抗幻觉的主要防线,并确保团队的提案在科学上是合理的。
接下来,我们将构建负责法规合规性的评判官。
# 评估器 2: 法规合规性 (LLM 作为评判官)
def regulatory_compliance_evaluator(generated_criteria: str, fda_context: str) -> GradedScore:
"""评估生成的标准是否符合提供的FDA指南。"""
evaluator_llm = llm_config['director'].with_structured_output(GradedScore)
# 这个提示词分配了不同的角色:“法规事务专家”。
prompt = ChatPromptTemplate.from_messages([
("system", "你是一位法规事务专家。请评估一组临床试验标准是否符合提供的FDA指南。1.0分表示完全合规。"),
("human", "评估以下标准:\n\n**生成的标准:**\n{criteria}\n\n**适用的FDA指南:**\n{context}")
])
chain = prompt | evaluator_llm
# 这次,我们使用法规专家检索到的上下文来调用链。
return chain.invoke({"criteria": generated_criteria, "context": fda_context})
regulatory_compliance_evaluator 函数是另一个专门的评判官。它唯一的关注点是将生成的标准与 fda_context 进行比较。通过为每个知识领域创建独立的、专注的评估器,我们得到了更有针对性、更可靠的反馈。这比使用一个单一的通用评估器来评判所有方面要好得多。
我们的第三个LLM评判官将衡量伦理合理性。
# 评估器 3: 伦理合理性 (LLM 作为评判官)
def ethical_soundness_evaluator(generated_criteria: str, ethics_context: str) -> GradedScore:
"""评估标准是否符合临床研究伦理的核心原则。"""
evaluator_llm = llm_config['director'].with_structured_output(GradedScore)
# 现在的角色是“临床试验伦理专家”。
prompt = ChatPromptTemplate.from_messages([
("system", "你是一位临床试验伦理专家。请评估一组标准是否符合提供的伦理原则(贝尔蒙报告摘要)。1.0分表示标准充分体现了对人的尊重、有利原则和公正原则。"),
("human", "评估以下标准:\n\n**生成的标准:**\n{criteria}\n\n**伦理原则:**\n{context}")
])
chain = prompt | evaluator_llm
# 我们使用伦理专家检索器提供的上下文。
return chain.invoke({"criteria": generated_criteria, "context": ethics_context})
ethical_soundness_evaluator 完成了我们三个LLM评判官的组合。它确保我们系统的输出不仅在科学和法律上合理,而且在伦理上也负责。对于任何现实世界的医疗AI应用来说,这都是一个关键组成部分。
现在,我们将转向程序化评估器。并非所有指标都需要LLM的细致推理。对于客观的、可量化的方面,简单的Python函数更快、更便宜,并且100%可靠。让我们构建招募可行性的评估器。
# 评估器 4: 招募可行性 (程序化)
def feasibility_evaluator(cohort_analyst_output: AgentOutput) -> GradedScore:
"""通过解析SQL分析师的输出中的患者数量并进行归一化,对可行性进行评分。"""
# 我们从患者队列分析师那里获取原始文本发现。
findings_text = cohort_analyst_output.findings
try:
# 我们从分析师格式化后的字符串中解析患者数量。
count_str = findings_text.split("database: ")[1].replace('.', '')
patient_count = int(count_str)
except (IndexError, ValueError):
# 如果解析失败,我们返回0.0分,因为可行性未知。
return GradedScore(score=0.0, reasoning="无法从分析师输出中解析患者数量。")
# 我们根据理想目标对分数进行归一化。对于II期试验,约150名患者是一个合理的目标。
IDEAL_COUNT = 150.0
# 分数是找到的患者数量与理想数量的比率,上限为1.0。
score = min(1.0, patient_count / IDEAL_COUNT)
reasoning = f"估计有{patient_count}名符合条件的患者。分数基于理想目标{int(IDEAL_COUNT)}进行归一化。"
return GradedScore(score=score, reasoning=reasoning)
它不需要LLM,因为评估纯粹是数学性的。它接收来自我们患者队列分析师的结构化输出,解析估计的患者数量,并将其归一化为0-1的分数。这个函数提供了一个硬性的、数据驱动的反馈信号。如果生成的标准过于严格,患者数量就会很低,这个分数也会很低,从而告诉我们的AI总监需要做出改变。
我们的最后一个评估器将是另一个程序化评估器,用于对操作简洁性进行评分。
# 评估器 5: 操作简洁性 (程序化)
def simplicity_evaluator(generated_criteria: str) -> GradedScore:
"""通过惩罚包含昂贵或复杂筛查测试的标准来评估简洁性。"""
# 我们定义了一个关键词列表,这些测试会增加患者筛查的显著成本和复杂性。
EXPENSIVE_TESTS = ["mri", "genetic sequencing", "pet scan", "biopsy", "echocardiogram", "endoscopy"]
# 我们统计这些关键词在生成的标准中出现了多少次(不区分大小写)。
test_count = sum(1 fortestin EXPENSIVE_TESTS iftestin generated_criteria.lower())
# 分数从1.0开始,每发现一个昂贵测试就扣减0.5分。
score = max(0.0, 1.0 - (test_count * 0.5))
reasoning = f"发现提及了{test_count}个昂贵/复杂的筛查程序。"
return GradedScore(score=score, reasoning=reasoning)
simplicity_evaluator 是一个简单但有效的启发式方法,用于估算操作成本。它充当一个“红旗”系统。通过扫描与昂贵程序相关的关键词,它对那些可能在科学上合理但难以大规模实施的标准进行扣分。这为我们的优化问题提供了另一个关键的、真实世界的约束条件。
创建聚合的 LangSmith 评估器
现在我们已经有了五个专家评估器,我们需要将它们封装到一个主函数中。这个聚合函数将编排整个评估系统,接收团队图的最终状态,并返回完整的5维性能向量,供我们的AI研究总监做决策时使用。
首先,让我们为最终的聚合结果定义Pydantic模型。
class EvaluationResult(BaseModel):
"""一个Pydantic模型,用于保存完整的5维评估结果。"""
rigor: GradedScore
compliance: GradedScore
ethics: GradedScore
feasibility: GradedScore
simplicity: GradedScore
EvaluationResult 类是我们评估体系的最终数据产品。它将来自五个维度的每个 GradedScore 整齐地打包成一个单一的、结构化的对象。
现在,我们可以构建主函数 run_full_evaluation。
def run_full_evaluation(guild_final_state: GuildState) -> EvaluationResult:
"""编排整个评估过程,依次调用五个专家评估器。"""
print("--- RUNNING FULL EVALUATION GAUNTLET ---")
# 从团队图的最终状态中提取必要的信息。
final_criteria = guild_final_state['final_criteria']
agent_outputs = guild_final_state['agent_outputs']
# 我们需要找到每个专家的特定发现结果,以便传递给正确的评估器。
# 我们使用 next() 并提供一个默认值,以安全处理某些Agent可能未运行的情况。
pubmed_context = next((o.findings for o in agent_outputs if o.agent_name == "Medical Researcher"), "")
fda_context = next((o.findings for o in agent_outputs if o.agent_name == "Regulatory Specialist"), "")
ethics_context = next((o.findings for o in agent_outputs if o.agent_name == "Ethics Specialist"), "")
analyst_output = next((o for o in agent_outputs if o.agent_name == "Patient Cohort Analyst"), None)
# 我们现在按顺序调用五个评估器函数。
print("Evaluating: Scientific Rigor...")
rigor = scientific_rigor_evaluator(final_criteria, pubmed_context)
print("Evaluating: Regulatory Compliance...")
compliance = regulatory_compliance_evaluator(final_criteria, fda_context)
print("Evaluating: Ethical Soundness...")
ethics = ethical_soundness_evaluator(final_criteria, ethics_context)
print("Evaluating: Recruitment Feasibility...")
feasibility = feasibility_evaluator(analyst_output) if analyst_output else GradedScore(score=0, reasoning="Analyst did not run.")
print("Evaluating: Operational Simplicity...")
simplicity = simplicity_evaluator(final_criteria)
print("--- EVALUATION GAUNTLET COMPLETE ---")
# 最后,我们将所有结果打包到我们的 EvaluationResult 模型中。
return EvaluationResult(rigor=rigor, compliance=compliance, ethics=ethics, feasibility=feasibility, simplicity=simplicity)
run_full_evaluation 函数是我们评估乐队的指挥。它接收包含团队运行所有产出的 guild_final_state,并仔细地将其拆包。它智能地将正确的上下文片段(例如 pubmed_context)路由到正确的评估器(例如 scientific_rigor_evaluator)。
这个函数是我们“内循环”的最后一步,将团队的原始文本输出转换为结构化的、多维度的性能向量,而“外循环”需要这个向量来开始进化过程。
让我们在前一部分从基线SOP运行中生成的输出上运行我们新的评估体系。
# 'final_result' 是保存我们第2.4节测试运行最终状态的变量。
baseline_evaluation_result = run_full_evaluation(final_result)
print("\nFull Evaluation Result for Baseline SOP:")
# 我们使用 .dict() 获取 Pydantic 模型的字典表示,以便漂亮地打印。
print(json.dumps(baseline_evaluation_result.dict(), indent=4))
这是我们得到的输出:
#### OUTPUT ####
--- RUNNING FULL EVALUATION GAUNTLET ---
Evaluating: Scientific Rigor...
Evaluating: Regulatory Compliance...
Evaluating: Ethical Soundness...
Evaluating: Recruitment Feasibility...
Evaluating: Operational Simplicity...
--- EVALUATION GAUNTLET COMPLETE ---
Full Evaluation Result for Baseline SOP:
{
"rigor": {
"score": 0.9,
"reasoning": "这些标准与一般知识基本一致..."
},
"compliance": {
"score": 0.95,
"reasoning": "这些标准强烈遵循了FDA指南中的原则..."
},
"ethics": {
"score": 1.0,
"reasoning": "这些标准极好地遵守了伦理原则..."
},
"feasibility": {
"score": 0.3933333333333333,
"reasoning": "估计有59名符合条件的患者。分数基于理想目标150进行归一化。"
},
"simplicity": {
"score": 1.0,
"reasoning": "发现提及了0个昂贵/复杂的筛查程序。"
}
}
这个结构化的输出是我们基线SOP的“成绩单”,它包含了一些重要的信息。它清晰地讲述了一个故事:我们初始的、人工设计的流程非常擅长生成科学严谨(0.9)、合规(0.95)、伦理(1.0)且简洁(1.0)的标准。
然而,它揭示了一个关键弱点:招募可行性。只有0.39的分数意味着,虽然该方案在纸面上“很好”,但在现实世界中很可能会失败,因为几乎不可能找到足够多的患者。
这正是我们的AI研究总监需要的精准的、可操作的、多维度的反馈。它不仅仅是被告知输出“不好”,而是确切地知道哪个维度出了问题以及为什么。现在,舞台已经完美地搭建好,接下来,总监将分析这份报告,并尝试进化SOP来解决这个具体的可行性问题。
进化引擎的外循环
我们已经成功构建并评估了我们的架构。我们有了一个能够生成高质量草案的系统,也有了能提供丰富5维性能向量的评估组件。但到目前为止,整个过程是静态的。对于相同的输入,团队每次都会产生相同的输出,带着相同的弱点。
现在,我们将构建我们自我改进系统的大脑:“AI研究总监”。这就是我们的“外循环”。它是一个更高层次的Agent系统,其任务不是设计临床试验,而是改进临床试验设计的过程。
它将分析来自我们评估体系的5维性能向量,诊断任何弱点的根本原因,并智能地重写团队自己的 GuildSOP 来解决这些问题。在这里,我们实现了核心的进化概念,使我们的系统能够学习和适应。
在本节中,我们将完成以下工作:
创建基因池: 我们将构建一个简单的类来存储和管理我们不断进化的SOP及其性能评分,创建一个流程配置的“基因池”。 设计总监级Agent: 我们将实现总监的两个核心Agent:性能诊断师(识别弱点)和SOP架构师(提出解决方案)。 构建进化循环架构: 然后定义一个主函数,编排一个完整的进化代次:诊断 -> 进化 -> 评估。 运行一个完整的进化周期: 我们将执行这个循环,展示系统自动识别基线SOP中的可行性弱点,并生成新的、变异的SOP来尝试修复它。
管理团队配置
在我们能够进化SOP之前,我们需要一个地方来存储它们。我们将创建一个简单的类来完成这项工作。这个类将跟踪我们系统生成的每个版本的 GuildSOP,以及其对应的5维评估结果和谱系(它是从哪个父版本进化而来的)。这提供了我们进化过程的完整、可追溯的历史记录。
class SOPGenePool:
"""一个简单的类,用于存储和管理 GuildSOP 及其评估结果的集合,充当我们的“基因池”。"""
def __init__(self):
# 池子将是一个字典列表,每个字典包含一个 SOP、其评估结果和元数据。
self.pool: List[Dict[str, Any]] = []
# 一个简单的计数器,为每个新的 SOP 分配一个唯一的版本号。
self.version_counter = 0
def add(self, sop: GuildSOP, eval_result: EvaluationResult, parent_version: Optional[int] = None):
"""向池中添加一个新的 SOP 及其评估结果。"""
self.version_counter += 1
entry = {
"version": self.version_counter,
"sop": sop,
"evaluation": eval_result,
"parent": parent_version # 追踪父版本对于分析进化路径至关重要。
}
self.pool.append(entry)
print(f"已将 SOP v{self.version_counter} 添加到基因池。")
def get_latest_entry(self) -> Optional[Dict[str, Any]]:
"""一个便捷方法,用于获取最近添加的条目。"""
return self.pool[-1] if self.pool else None
SOPGenePool 类是一个简单但重要的数据管理工具。它是我们进化过程的实验笔记本。add 方法是关键函数,它将每个新的 GuildSOP 连同其性能数据一起编目。通过存储 parent_version,我们创建了一个清晰的祖先链。
这将使我们以后能够追溯一个高度成功的SOP,并理解导致其发现的变异序列。这是为Agent自己的“源代码”实现的一个简单的版本控制系统。
构建总监级Agent
现在,我们定义构成我们进化引擎核心的两个Agent。这些Agent在更高层次的抽象上运作。它们不讨论医学或法规,而是讨论流程和性能。
首先是性能诊断师。这个Agent的任务是查看来自评估体系的5维性能向量,并找出最大的问题。
class Diagnosis(BaseModel):
"""一个 Pydantic 模型,用于诊断Agent的结构化输出。"""
# 主要弱点必须是五个维度之一。
primary_weakness: Literal['rigor', 'compliance', 'ethics', 'feasibility', 'simplicity']
# 对弱点为何发生的详细分析,将其推理建立在具体分数上。
root_cause_analysis: str = Field(description="对弱点为何发生的详细分析,参考具体分数。")
# 关于如何解决问题的战略性、高层次建议。
recommendation: str = Field(description="关于如何修改 SOP 以解决弱点的高层次建议。")
def performance_diagnostician(eval_result: EvaluationResult) -> Diagnosis:
"""分析5维评估向量,诊断主要弱点。"""
print("--- EXECUTING PERFORMANCE DIAGNOSTICIAN ---")
# 我们使用最强大的 'director' 模型(Llama 3 70B)来完成这个关键的推理任务。
diagnostician_llm = llm_config['director'].with_structured_output(Diagnosis)
# 提示词为Agent分配了管理顾问的角色,专注于流程优化。
prompt = ChatPromptTemplate.from_messages([
("system", "你是一位世界级的管理顾问,专攻流程优化。你的任务是分析一份绩效评分卡,找出最大的弱点。然后,提供根本原因分析和战略性建议。"),
("human", "请分析以下绩效评估报告:\n\n{report}")
])
chain = prompt | diagnostician_llm
# 我们使用完整评估结果的 JSON 表示来调用链。
return chain.invoke({"report": eval_result.json()})
让我们理解一下我们的第一个Agent……
performance_diagnostician Agent是我们RAG流水线的“医生”。它接收 EvaluationResult(“症状”),并产生结构化的 Diagnosis。
通过强制它从 Literal 集合中识别出 primary_weakness 并提供 root_cause_analysis,我们引导它执行一个聚焦的分析任务。它的输出不仅仅是一个抱怨,而是一个可操作的洞察,将直接为进化循环中的下一个Agent提供信息。
第二个Agent是SOP架构师。这个Agent是进化者,它接收上一步的诊断和当前的 GuildSOP,其任务是生成几个新的、变异的SOP版本,每个版本代表解决已识别问题的不同策略。
class EvolvedSOPs(BaseModel):
"""一个 Pydantic 容器,用于存放一系列新的、进化后的 GuildSOP。"""
mutations: List[GuildSOP]
def sop_architect(diagnosis: Diagnosis, current_sop: GuildSOP) -> EvolvedSOPs:
"""接收诊断和当前 SOP,并生成一系列新的、变异的 SOP 进行测试。"""
print("--- EXECUTING SOP ARCHITECT ---")
# 我们再次使用强大的 'director' 模型,这次配置为输出 GuildSOP 对象的列表。
architect_llm = llm_config['director'].with_structured_output(EvolvedSOPs)
# 这个提示词非常具体。它告诉Agent其任务是修改一个 JSON 对象(即 SOP)
# 以修复特定问题。我们甚至在提示词中提供了 SOP 的 JSON 模式作为上下文。
prompt = ChatPromptTemplate.from_messages([
("system", f"你是一位 AI 流程架构师。你的工作是修改一个流程配置(一个 SOP)来修复已诊断的问题。SOP 是一个 JSON 对象,其模式如下:{GuildSOP.schema_json()}。你必须在 'mutations' 键下返回一个包含 2-3 个新的、有效的 SOP JSON 对象的列表。提出多样化和创造性的变异。例如,你可以更改提示词、切换Agent、更改检索参数,甚至更改用于某项任务的模型。只修改与诊断相关的字段。"),
("human", "以下是当前的 SOP:\n{current_sop}\n\n以下是性能诊断:\n{diagnosis}\n\n根据诊断,请生成 2-3 个新的、改进的 SOP。")
])
chain = prompt | architect_llm
return chain.invoke({"current_sop": current_sop.json(), "diagnosis": diagnosis.json()})
sop_architect 是我们自我改进系统的创意引擎。它的提示词是一种指令工程。我们告诉 LLM:“你是一名程序员。这是源代码(current_sop)。这是错误报告(diagnosis)。现在,编写 2-3 个不同的补丁(mutations)来尝试修复这个错误”。
通过在提示词中直接提供 GuildSOP.schema_json(),我们大大增加了 LLM 生成有效、格式正确的新 SOP 的可能性。这个Agent不只是随机更改东西,而是基于诊断师识别的具体问题,提出有针对性的、智能的修改。
运行完整的进化循环
我们现在已经拥有了单次进化代次的所有组件:用于存储结果的基因池、用于识别问题的诊断师、以及用于提出解决方案的架构师。现在,我们可以将它们封装到一个主函数中,编排一个完整的“诊断 -> 进化 -> 评估”循环。
def run_evolution_cycle(gene_pool: SOPGenePool, trial_request: str):
"""运行一个完整的诊断、变异和再评估循环。"""
print("\n" + "="*25 + " 开始新的进化循环 " + "="*25)
# 步骤 1:选择当前最佳的 SOP 进行改进。为简单起见,我们只取基因池中最新添加的那个。
current_best_entry = gene_pool.get_latest_entry()
parent_sop = current_best_entry['sop']
parent_eval = current_best_entry['evaluation']
parent_version = current_best_entry['version']
print(f"正在改进 SOP v{parent_version}...")
# 步骤 2:诊断父 SOP 的性能。
diagnosis = performance_diagnostician(parent_eval)
print(f"诊断完成。主要弱点:'{diagnosis.primary_weakness}'。建议:{diagnosis.recommendation}")
# 步骤 3:基于诊断构建新的 SOP 候选方案。
new_sop_candidates = sop_architect(diagnosis, parent_sop)
print(f"生成了 {len(new_sop_candidates.mutations)} 个新的 SOP 候选方案。")
# 步骤 4:通过运行完整的团队图和评估体系来评估每个新候选方案。
for i, candidate_sop in enumerate(new_sop_candidates.mutations):
print(f"\n--- 正在测试 SOP 候选方案 {i+1}/{len(new_sop_candidates.mutations)} ---")
# 我们使用新的、变异的 SOP 运行整个内循环(团队)。
guild_input = {"initial_request": trial_request, "sop": candidate_sop}
final_state = guild_graph.invoke(guild_input)
# 然后,我们对输出运行完整的评估体系。
eval_result = run_full_evaluation(final_state)
# 最后,我们将新的 SOP 及其性能添加到基因池中。
gene_pool.add(sop=candidate_sop, eval_result=eval_result, parent_version=parent_version)
print("\n" + "="*25 + " 进化循环完成 " + "="*26)
run_evolution_cycle 函数是我们外循环的主要编排器。它将遗传算法过程形式化。它从上一代中选取性能最佳的 SOP,使用总监级Agent来诊断其缺陷并构建潜在的改进方案,然后通过完整的内循环和评估体系对每一个新的“子代” SOP 进行严格的测试。这个函数代表了系统自我改进飞轮的一次完整转动。
让我们把所有部分组合在一起。我们将初始化 SOPGenePool,添加我们的基线 SOP 及其评估结果,然后运行一个进化循环。
# 初始化我们的基因池。
gene_pool = SOPGenePool()
print("已初始化 SOP 基因池。")
# 添加我们的基线 SOP (v1) 及其先前计算的评估结果作为第一个条目。
gene_pool.add(sop=baseline_sop, eval_result=baseline_evaluation_result)
# 现在,从我们的基线开始,执行一个完整的进化循环。
run_evolution_cycle(gene_pool, test_request)
当我们运行这段代码时,得到了以下输出:
#### OUTPUT ####
已初始化 SOP 基因池。
已将 SOP v1 添加到基因池。
# ========================= 开始新的进化循环 =========================
正在改进 SOP v1...
# --- 正在执行性能诊断师 ---
诊断完成。主要弱点:'feasibility'。建议:主要目标应是修改 SOP 以提高估计患者数量...
# --- 正在执行 SOP 架构师 ---
生成了 2 个新的 SOP 候选方案。
# --- 正在测试 SOP 候选方案 1/2 ---
# --- 正在执行规划Agent ---
...
# --- 正在执行患者队列分析师 ---
查询执行成功。估计患者数量:121
...
# --- 正在运行完整评估体系 ---
已将 SOP v2 添加到基因池。
# --- 正在测试 SOP 候选方案 2/2 ---
# --- 正在执行规划Agent ---
...
# --- 正在执行医学研究员 ---
使用 k=5 进行检索。
...
# --- 正在运行完整评估体系 ---
已将 SOP v3 添加到基因池。
# ========================= 进化循环完成 ==========================
输出展示了我们自主系统的工作过程:
性能诊断师正确分析了 SOP v1 的评估结果,并将 'feasibility' 确定为主要弱点。SOP 架构师基于这个诊断生成了两个新的、有针对性的变异方案来尝试解决问题。然后,系统严格测试了这些新候选方案(SOP v2 和 SOP v3),为两者都运行了完整的内循环和评估系统。 最后,两个新的 SOP 及其性能结果都被添加到了我们的 SOPGenePool中。
整个过程完全按照设计运行。系统自主地识别了问题,生成并测试了潜在的解决方案。下一步是分析这个循环的结果,看看提出的变异方案是否成功。
基于5维帕累托的分析
我们的进化循环已完成一个完整的周期。它诊断了基线 SOP 的弱点,并生成并测试了两个旨在解决该问题的新的“突变” SOP。SOPGenePool 现在包含了三种不同的流程配置,每种都有一个完整的5维性能向量。
现在到了最后一步:分析这些结果以做出决策。在多目标优化问题中,通常不存在单一的“最佳”解决方案。相反,存在一组最优的权衡方案,称为帕累托前沿。我们的目标是识别这个前沿,并将其呈现给人类决策者。
在这最后一节中,我们将完成以下工作:
分析基因池: 我们首先打印所有 SOP 及其性能分数的摘要,以观察变异的直接影响。 识别帕累托前沿: 我们将编写一个函数,以编程方式识别基因池中的非支配解集,即代表最佳可能权衡的 SOP 集合。 可视化前沿: 创建一个强大的可视化图表——平行坐标图,使我们能够同时看到最优 SOP 在所有五个维度上的表现,使权衡关系清晰直观。
首先,让我们打印出当前基因池中所有 SOP 的分数,以便对结果有一个高层次的概览。
# 我们将遍历基因池,并打印每个条目的格式化性能摘要。
print("SOP 基因池评估摘要:")
print("---------------------------------")
for entry in gene_pool.pool:
v = entry['version']
p = entry['parent']
evals = entry['evaluation']
# 从每个 GradedScore 对象中提取分数。
r, c, e, f, s = evals.rigor.score, evals.compliance.score, evals.ethics.score, evals.feasibility.score, evals.simplicity.score
parent_str = f"(父代)"if p is None else f"(v{p} 的子代)"
print(f"SOP v{v:<2} {parent_str:<14}: 严谨性={r:.2f}, 合规性={c:.2f}, 伦理性={e:.2f}, 可行性={f:.2f}, 简洁性={s:.2f}")
当我们运行这段代码时,得到的是整体性能数据:
#### OUTPUT ####
SOP 基因池评估摘要:
---------------------------------
SOP v1 (父代) : 严谨性=0.90, 合规性=0.95, 伦理性=1.00, 可行性=0.39, 简洁性=1.00
SOP v2 (v1 的子代) : 严谨性=0.85, 合规性=0.95, 伦理性=1.00, 可行性=0.81, 简洁性=1.00
SOP v3 (v1 的子代) : 严谨性=0.90, 合规性=0.95, 伦理性=1.00, 可行性=0.39, 简洁性=1.00
这个汇总表提供了一些分析信息。它直接证明了我们的自主系统是有效的。
我们的 AI 总监正确识别出 SOP v1 的 可行性分数为 0.39。然后它生成了 SOP v2,一个旨在解决此问题的变异方案。结果是巨大的成功: 可行性分数翻了一倍多,达到 0.81!这伴随着在严谨性上一个小的、可接受的下降(从 0.90 降至 0.85),展示了一种智能的权衡。它还生成了 SOP v3,它尝试了不同的策略(增加研究员的 k值)。这对可行性没有影响,表明系统能够探索不同的路径,但并非所有路径都能成功。
我们成功创建了一个能够反思自身失败并智能地重写其内部流程以进行改进的系统。
识别帕累托前沿
现在,我们需要将“最优权衡”的概念形式化。在我们的基因池中,一些解决方案可能严格劣于其他解决方案。例如,SOP v3 在四个指标上与 SOP v1 得分相同,在可行性上也不相上下。因此没有理由选择 v3。我们说 v3 被 v1 “支配”了。
帕累托前沿是所有非支配解的集合。我们将编写一个函数从基因池中识别出这个集合。
import numpy as np
def identify_pareto_front(gene_pool: SOPGenePool) -> List[Dict[str, Any]]:
"""识别基因池中的非支配解(帕累托前沿)。"""
pareto_front = []
pool_entries = gene_pool.pool
# 我们将每个解与其他所有解进行比较。
for i, candidate in enumerate(pool_entries):
is_dominated = False
# 获取候选解的5维分数向量。
cand_scores = np.array([s['score'] for s in candidate['evaluation'].dict().values()])
for j, other in enumerate(pool_entries):
if i == j: continue# 不将解与自身比较。
# 获取另一个解的5维分数向量。
other_scores = np.array([s['score'] for s in other['evaluation'].dict().values()])
# 支配条件:如果 'other' 在所有指标上都 >= 'candidate',
# 并且在至少一个指标上严格 > 'candidate',则 'other' 支配 'candidate'。
if np.all(other_scores >= cand_scores) and np.any(other_scores > cand_scores):
is_dominated = True
break# 一旦找到一个支配它的解,我们就可以停止检查。
# 如果在检查了所有其他解之后,没有解支配我们的候选解,那么它就在帕累托前沿上。
if not is_dominated:
pareto_front.append(candidate)
return pareto_front
identify_pareto_front 函数是帕累托支配检查的经典实现。这是一种暴力但有效的算法,它将每个 SOP 的5维性能向量与所有其他 SOP 的向量进行系统性比较。逻辑 np.all(other_scores >= cand_scores) and np.any(other_scores > cand_scores) 是帕累托支配的正式数学定义。这个函数将把整个基因池精简到仅剩最合理、最优的选择。
让我们在基因池上运行它,看看哪些 SOP 符合条件。
# 运行函数以识别最优 SOP。
pareto_sops = identify_pareto_front(gene_pool)
print("帕累托前沿上的 SOP:")
print("-------------------------")
for entry in pareto_sops:
v = entry['version']
evals = entry['evaluation']
r, c, e, f, s = evals.rigor.score, evals.compliance.score, evals.ethics.score, evals.feasibility.score, evals.simplicity.score
print(f"SOP v{v}: 严谨性={r:.2f}, 合规性={c:.2f}, 伦理性={e:.2f}, 可行性={f:.2f}, 简洁性={s:.2f}")
#### OUTPUT ####
帕累托前沿上的 SOP:
-------------------------
SOP v1: 严谨性=0.90, 合规性=0.95, 伦理性=1.00, 可行性=0.39, 简洁性=1.00
SOP v2: 严谨性=0.85, 合规性=0.95, 伦理性=1.00, 可行性=0.81, 简洁性=1.00
算法正确识别出 SOP v1 和 v2 构成了我们的帕累托前沿。SOP v3 被正确排除,因为它被 SOP v1 支配。这是我们整个系统的最终、精炼的输出。它没有给我们一个单一的“最佳”答案。相反,它为人类决策者提供了一个由最优但不同的策略组成的菜单:
SOP v1:“最大严谨性”策略,优先考虑科学纯粹性,但牺牲了招募可行性。 SOP v2:“高可行性”策略,在严谨性上做出小的牺牲,以换取现实世界实用性的大幅提升。
这两者之间的最终选择是一个战略性的商业决策,而非纯粹的技术决策。我们的工作完成了:它已经找到并呈现了最佳的权衡方案。
可视化前沿并做出决策
可视化一个5维空间是不可能的。然而,有一些技术可以展示高维度的权衡关系。其中最好的一种是平行坐标图。该图将每个 SOP 绘制为一条线,每条垂直轴代表我们的五个性能支柱之一。它使我们能够立即看到每个策略在所有维度上的表现以及权衡关系所在。
我们将编写一个函数来生成此图,同时还有一个更简单的2维散点图,专注于我们发现的主要的“严谨性 vs. 可行性”权衡。
import matplotlib.pyplot as plt
import pandas as pd
def visualize_frontier(pareto_sops):
"""创建2维散点图和平行坐标图来可视化帕累托前沿。"""
if not pareto_sops:
print("没有可可视化的帕累托前沿 SOP。")
return
# 创建一个包含两个并排子图的图形。
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(18, 7))
# --- 图 1:2维散点图 (严谨性 vs. 可行性) ---
labels = [f"v{s['version']}"for s in pareto_sops]
rigor_scores = [s['evaluation'].rigor.score for s in pareto_sops]
feasibility_scores = [s['evaluation'].feasibility.score for s in pareto_sops]
ax1.scatter(rigor_scores, feasibility_scores, s=200, alpha=0.7, c='blue')
for i, txt in enumerate(labels):
ax1.annotate(txt, (rigor_scores[i], feasibility_scores[i]), xytext=(10,-10), textcoords='offset points', fontsize=14)
ax1.set_title('帕累托前沿:严谨性 vs. 可行性', fontsize=16)
ax1.set_xlabel('科学严谨性得分', fontsize=14)
ax1.set_ylabel('招募可行性得分', fontsize=14)
ax1.grid(True, linestyle='--', alpha=0.6)
ax1.set_xlim(min(rigor_scores)-0.05, max(rigor_scores)+0.05)
ax1.set_ylim(min(feasibility_scores)-0.1, max(feasibility_scores)+0.1)
# --- 图 2:用于5维分析的平行坐标图 ---
data = []
for s in pareto_sops:
eval_dict = s['evaluation'].dict()
scores = {k.capitalize(): v['score'] for k, v in eval_dict.items()}
scores['SOP Version'] = f"v{s['version']}"
data.append(scores)
df = pd.DataFrame(data)
# 来自 pandas 的核心绘图函数。
pd.plotting.parallel_coordinates(df, 'SOP Version', colormap=plt.get_cmap("viridis"), ax=ax2, axvlines_kwargs={"linewidth": 1, "color": "grey"})
ax2.set_title('帕累托前沿上的5维性能权衡', fontsize=16)
ax2.grid(True, which='major', axis='y', linestyle='--', alpha=0.6)
ax2.set_ylabel('归一化得分', fontsize=14)
ax2.legend(loc='lower center', bbox_to_anchor=(0.5, -0.15), ncol=len(labels))
plt.tight_layout()
plt.show()
这个 visualize_frontier 函数是我们的最终报告工具。它接收最优的 pareto_sops 列表,并创建两个强大的可视化图表。散点图提供了我们最冲突目标之间二维权衡的经典视图。
平行坐标图是关键,它展示了每个最优 SOP 的完整5维性能轮廓,使人类决策者能够一目了然地看到全貌。
让我们在我们识别出的帕累托前沿上运行这个可视化。
# 此单元格的输出将显示包含我们两个可视化图表的 Matplotlib 图。
visualize_frontier(pareto_sops)
这个最终的可视化是我们整个系统的最终输出。它不仅仅是一个答案,更是一个决策支持工具。
散点图(左) 清晰地显示了权衡关系。要从 v1 到 v2,我们必须接受“科学严谨性”的微小下降,以换取“招募可行性”的大幅提升。 平行坐标图(右) 讲述了完整的故事。我们可以追踪 v1 和 v2 的线条。我们看到它们在“合规性”、“伦理性”和“简洁性”轴上是相同的。线条仅在“严谨性”和“可行性”上出现分歧。这两条轴之间的“交叉”模式是权衡关系的经典视觉特征。用户可以立即看到 v2 的线在可行性上高得多,而 v1 的线在严谨性上略高。
这个可视化为人类专家提供了信息。他们不必信任一个黑箱,而是可以看到 AI 发现的最优策略,并根据自己的优先级做出最终、明智的决策。
如果试验是一项高风险、探索性的研究,科学纯粹性至关重要,他们可能会选择 v1。如果这是一项后期试验,快速招募是首要任务,他们几乎肯定会选择 v2。
理解认知工作流
我们已经成功构建了一个能够进化并改进自身流程的系统。我们在基因池摘要和帕累托前沿中看到了高层次的结果。但是,一次高性能的运行在内部实际看起来是怎样的?Agent如何协作?时间花费在哪里?最终的性能分数如何转化为可视化的轮廓?
为了回答这些问题,我们需要从进化的宏观视角转向单个认知周期的微观视角。在本节中,我们将对我们改进后的 SOP v2 的一次完整运行进行法证分析。我们将把团队从一个“黑箱”变成一个“玻璃箱”,详细观察其内部机制。
以下是我们要做的:
为工作流添加探针: 我们将创建一个新的调用函数,精确测量 LangGraph中每个Agent执行的开始时间、结束时间和持续时间。可视化执行时间线: 我们将使用这些时间数据生成一个甘特图,提供团队工作流的清晰直观的可视化,突出显示并行和顺序操作。 剖析性能向量: 我们将创建一个雷达图,以可视化我们的基线和改进后 SOP 的5维性能向量,使多目标权衡一目了然。
可视化Agent工作流时间线
首先,我们希望了解团队协作的过程。它真的是并行的吗?哪个Agent是瓶颈?为了找到答案,我们需要为图执行添加探针,以捕获每个节点的时间信息。
我们将编写一个新的包装函数 invoke_with_timing,它使用我们编译后图的 .stream() 方法。stream() 方法是一个强大的特性,它会在每个节点完成时产生该节点的输出。通过记录每个节点执行前后的时间戳,我们可以捕获构建时间线所需的原始数据。
import time
from collections import defaultdict
def invoke_with_timing(graph, sop, request):
"""调用团队图,同时捕获每个节点的开始和结束时间。"""
print(f"--- 正在为 SOP 进行插桩图运行: {sop.dict()} ---")
# 这个列表将存储我们的时间数据。
timing_data = []
# 我们使用 defaultdict 来跟踪每个节点的开始时间。
start_times = defaultdict(float)
# 图的初始输入。
graph_input = {"initial_request": request, "sop": sop}
# 我们使用 .stream() 来获取图中每个节点执行时的更新。
for event in graph.stream(graph_input, stream_mode="values"):
# 事件中字典的键是刚刚运行的节点的名称。
node_name = list(event.keys())[0]
# 我们记录当前时间作为刚刚完成节点的结束时间。
end_time = time.time()
# 如果这是我们第一次看到这个节点,这是它的开始时间。
# 这个逻辑是一个简化;为了获取真实的开始时间,我们需要挂钩到事件的 'start'。
# 对于我们这样的线性图,这是一个合理的近似。
if node_name not in start_times:
start_times[node_name] = end_time - 0.1 # 近似开始时间
start_time = end_time - duration
# 我们将收集到的数据追加到列表中。
timing_data.append({
"node": node_name,
"start_time": start_time,
"end_time": end_time,
"duration": duration
})
start_times[node_name] = start_time
# 找到整体开始时间以归一化我们的时间线。
overall_start_time = min(d['start_time'] for d in timing_data)
for data in timing_data:
data['start_time'] -= overall_start_time
data['end_time'] -= overall_start_time
# 最后一个事件包含完整的最终状态。
final_state = event[list(event.keys())[-1]]
return final_state, timing_data
invoke_with_timing 函数是我们的插桩层。它包装了标准的 .stream() 调用并添加了性能监控。对于流产生的每个事件,它捕获节点名称和时间戳。
让我们用我们成功的 SOP v2 运行这个函数,以捕获其性能轮廓。
# 我们将使用基因池中的第二个条目,即成功的 SOP v2。
sop_v2 = gene_pool.pool[1]['sop']
final_state_v2, timing_data_v2 = invoke_with_timing(guild_graph, sop_v2, test_request)
print("\n--- 已捕获 SOP v2 的时间数据 ---")
print(json.dumps(timing_data_v2, indent=2))
让我们运行这段代码,看看 SOP v2 的持续时间进度:
#### OUTPUT ####
--- 正在为 SOP 进行插桩图运行: {'planner_prompt': '...', 'researcher_retriever_k': 3, ...} ---
# --- 正在执行规划Agent ---
...
# --- 正在执行关键标准综合者 ---
...
# --- 已捕获 SOP v2 的时间数据 ---
[
{
"node": "planner",
"start_time": 0.0,
"end_time": 5.2,
"duration": 5.2
},
{
"node": "execute_specialists",
"start_time": 5.2,
"end_time": 20.7,
"duration": 15.5
},
{
"node": "synthesizer",
"start_time": 20.7,
"end_time": 25.5,
"duration": 4.8
}
]
输出显示,我们已成功捕获了团队工作流每个主要阶段的执行时间。我们有了原始数据:planner 耗时 5.2 秒,execute_specialists 节点耗时 15.5 秒,synthesizer 耗时 4.8 秒。这些数据很有用,但不够直观。我们现在需要将其可视化。
现在,我们将编写一个函数,接收这些时间数据并将其绘制成甘特图。这将使我们能够直观地理解工作流的时间线。
import matplotlib.pyplot as plt
def plot_gantt_chart(timing_data: List[Dict[str, Any]], title: str):
"""根据时间数据绘制Agent工作流的甘特图。"""
fig, ax = plt.subplots(figsize=(12, 4))
# 获取节点的名称作为 y 轴标签。
labels = [d['node'] for d in timing_data]
# 甘特图的核心:水平条形图。
# 'left' 参数设置条形的开始时间。
ax.barh(labels, [d['duration'] for d in timing_data], left=[d['start_time'] for d in timing_data], color='skyblue')
ax.set_xlabel('时间 (秒)')
ax.set_title(title, fontsize=16)
ax.grid(True, which='major', axis='x', linestyle='--', alpha=0.6)
# 反转 y 轴,使第一个任务位于顶部。
ax.invert_yaxis()
plt.show()
这个 plot_gantt_chart 函数是一个标准的 Matplotlib 绘图工具。它接收我们的时间数据字典列表,并使用 ax.barh 创建水平条。关键在于 left 参数,它将每个条偏移到正确的开始时间,而条形的宽度则设置为其 duration。这个简单的技术足以将我们的数值数据转换为直观的时间线。
让我们用刚捕获的数据运行它。
plot_gantt_chart(timing_data_v2, "试验设计团队执行时间线 (SOP v2)")
这个甘特图提供了对我们团队内部工作流的强大而清晰的可视化。它是“黑箱”变得透明。我们可以立即看到:
顺序流程: 该过程是顺序的,从 planner到execute_specialists再到synthesizer,完全符合我们在LangGraph中的设计。瓶颈: execute_specialists节点是迄今为止过程中运行时间最长的部分。这完全符合预期,因为它涉及多个独立的子任务(四个不同的Agent调用,有些涉及 RAG,一个涉及文本到 SQL 流程)。并行性洞察: 虽然我们的顶层图是顺序的,但这个可视化清楚地表明, execute_specialists节点内部的工作才是并行化发生的地方。如果我们对该节点内的子任务进行插桩,就会看到四个专家Agent是并发运行的。
这种时间线分析对于性能优化至关重要。它立即告诉我们,如果我们想加快团队的速度,我们的努力应该几乎完全集中在优化 execute_specialists 节点上。
使用雷达图剖析输出
甘特图向我们展示了流程的性能。现在,让我们可视化结果的性能。我们的评估系统产生一个5维分数向量。一个简单的数字表格很难解释。雷达图(或蜘蛛图)是完美的工具,因为它可以将多维轮廓映射到直观的2D形状上。
我们将编写一个函数,接收 EvaluationResult 对象,并将它们的5维分数向量绘制在单个雷达图上。这将使我们能够直观地比较不同 SOP 的性能轮廓。
import pandas as pd
def plot_radar_chart(eval_results: List[Dict[str, Any]], labels: List[str]):
"""创建雷达图,比较多个 SOP 的5维性能。"""
# 雷达图轴线的类别是五个质量支柱。
categories = ['严谨性', '合规性', '伦理性', '可行性', '简洁性']
num_vars = len(categories)
# 我们计算图上每个轴的角度。
angles = np.linspace(0, 2 * np.pi, num_vars, endpoint=False).tolist()
# 绘图需要是一个闭合的环,所以我们在末尾重复第一个角度。
angles += angles[:1]
fig, ax = plt.subplots(figsize=(8, 8), subplot_kw=dict(polar=True))
# 将每个 SOP 的性能作为雷达图上的一条单独的线/形状进行绘制。
for i, result in enumerate(eval_results):
# 提取分数,并在末尾重复第一个分数以闭合形状。
values = [res.score for res in result.dict().values()]
values += values[:1]
ax.plot(angles, values, linewidth=2, linestyle='solid', label=labels[i])
ax.fill(angles, values, alpha=0.25)
ax.set_yticklabels([])
ax.set_xticks(angles[:-1])
ax.set_xticklabels(categories, fontsize=12)
ax.set_title('5维性能轮廓对比', size=20, color='blue', y=1.1)
plt.legend(loc='upper right', bbox_to_anchor=(1.3, 1.1))
plt.show()
我们再次使用 Matplotlib 的 polar=True 投影来创建圆形布局。核心逻辑涉及为我们的五个类别计算角度,然后将每个 SOP 的分数绘制为连接这些角度的线。
ax.fill 命令添加了半透明的颜色,使得每个 SOP 性能轮廓的“足迹”易于查看和比较。
让我们运行这个函数来比较我们的基线 SOP v1 和进化后的成功 SOP v2。
# 我们从基因池中收集 SOP v1 和 SOP v2 的评估结果。
evals_to_plot = [
gene_pool.pool[0]['evaluation'], # SOP v1
gene_pool.pool[1]['evaluation'] # SOP v2
]
labels_for_plot = ['SOP v1 (基线)', 'SOP v2 (进化后)']
plot_radar_chart(evals_to_plot, labels_for_plot)
它将抽象的5维性能向量转化为即时、直观的战略轮廓比较。
共同优势: 我们可以立即看到基线 SOP(蓝色)和进化后的 SOP(橙色)在“合规性”、“伦理性”和“简洁性”上几乎完美。它们的形状都延伸到了这三个轴的外缘。这告诉我们,我们的初始设计在这些领域已经很强大。 权衡: 关键洞察来自“严谨性”和“可行性”轴。我们可以看到一个清晰的权衡。蓝色形状(SOP v1)在“严谨性”轴上略微延伸得更远,证实了其更高的分数。然而,橙色形状(SOP v2)在“可行性”轴上显著突出,视觉上代表了其在该指标上的巨大改进。
这个图表是我们 AI 研究总监的最终报告。它证明了进化不是随机的;而是一个有针对性的、智能的优化过程。
系统识别出一个特定的弱点(可行性),并成功进化出一个新的流程(SOP v2),该流程显著改善了这一点,同时在另一个领域(严谨性)做出了最小的、战略性的牺牲。 这种可视化使复杂的多目标权衡变得清晰,使人类专家能够自信地选择 SOP v2 作为整体上更优的策略。
使其成为一个自主策略系统
我们已经成功设计、构建并演示了一个完整的、自我改进的Agent系统。这个架构不仅仅是一个解决方案;它是一个基础。我们确立的原则——分层Agent设计、动态 SOP、多维评估和自动进化——开启了大量的未来可能性。
我认为我们可以按以下方向继续推进这项研究:
首先,我们可以持续运行进化循环。 我们已经完成了一个周期,下一步是将其运行数百代,以发现更丰富、更多样化的、经过实战检验的最优 SOP 帕累托前沿。 我们还可以将总监的推理提炼成一个更小的策略模型。 通过在成功的变异历史数据上进行训练,我们可以用更快、更便宜、更专业的模型替换掉大型的 70B 总监 LLM,使进化过程更高效。 我们可以授权 AI 总监动态改变团队的结构。 总监可以学习根据试验概念的具体需求添加新的专家(如“生物统计学家”)或移除其他专家,从而使团队本身也发生进化。 我们还可以用实时 API 访问来替换我们静态的 MIMIC-III 数据库。 将 患者队列分析师连接到安全的、实时的电子健康记录系统,将使其可行性估计基于最新的患者数据。我们还可以用更高级的进化算子来增强 SOP 架构师。除了生成变异,它还可以学习使用“交叉”技术,将两个不同成功 SOP 的最佳部分结合起来,加速新策略的发现。最后,我们可以用人类专家的反馈来闭环。 我们可以将人类临床科学家的评分直接整合到评估体系中,利用他们的专家判断作为最终的奖励信号,引导系统走向不仅在技术上最优,而且在实践中也极其出色的解决方案。
🏴☠️宝藏级🏴☠️ 原创公众号『数据STUDIO』内容超级硬核。公众号以Python为核心语言,垂直于数据科学领域,包括可戳👉Python|MySQL|数据分析|数据可视化|机器学习与数据挖掘|爬虫等,从入门到进阶!
长按👇关注- 数据STUDIO -设为星标,干货速递