基于多 Agent 架构的医疗病历处理系统代码详解_deepseek 慢病管理代码-优快云博客

本文链接：https://blog.youkuaiyun.com/Ljugg/article/details/146245430

基于多 Agent 架构的医疗病历处理系统代码详解

引言

在医疗领域，对病历信息的有效处理和分析至关重要。本文将详细解释一个基于多 Agent 架构的医疗病历处理系统的代码，该系统借助 Ollama 加载本地的 DeepSeek 32B 模型，实现了从病历查询到预后预测的一系列功能。下面我们将逐句剖析每个 Agent 的代码。

1. 查询 Agent（`query_agent.py`）

import psycopg2
from langchain.llms import Ollama
from langchain import SQLDatabase, SQLDatabaseChain

解释：
- import psycopg2：导入 psycopg2 库，它是 Python 连接 PostgreSQL 数据库的常用库。
- from langchain.llms import Ollama：从 langchain 库的 llms 模块导入 Ollama 类，用于加载和调用 Ollama 服务中的大语言模型。
- from langchain import SQLDatabase, SQLDatabaseChain：从 langchain 库导入 SQLDatabase 和 SQLDatabaseChain 类，前者用于表示数据库连接，后者用于实现文本到 SQL 查询的转换。

# 内存存储
memory = {}

解释：创建一个空字典 memory，用于存储已经执行过的查询及其结果，避免重复查询数据库。

# 加载本地 Ollama 的 DeepSeek 32B 模型
llm = Ollama(model="deepseek-32b")

解释：实例化 Ollama 类，指定加载本地的 deepseek - 32b 模型，后续将使用该模型进行文本到 SQL 的转换。

# 连接到 PostgreSQL 数据库
def connect_to_db():
    try:
        conn = psycopg2.connect(
            database="your_database",
            user="your_user",
            password="your_password",
            host="your_host",
            port="your_port"
        )
        return conn
    except Exception as e:
        print(f"数据库连接错误: {e}")
        return None

解释：定义 connect_to_db 函数，用于建立与 PostgreSQL 数据库的连接。使用 try - except 块捕获可能的连接错误，并在出错时打印错误信息。若连接成功，返回数据库连接对象 conn；若失败，返回 None。

# text2sql 功能
def text2sql(query_text):
    db = SQLDatabase.from_uri("postgresql+psycopg2://your_user:your_password@your_host:your_port/your_database")
    db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True)
    result = db_chain.run(query_text)
    return result

解释：定义 text2sql 函数，实现文本到 SQL 查询的转换。首先，使用 SQLDatabase.from_uri 方法创建一个数据库连接对象 db。然后，使用 SQLDatabaseChain.from_llm 方法创建一个 SQLDatabaseChain 对象 db_chain，该对象结合了大语言模型 llm 和数据库连接 db。最后，调用 db_chain.run 方法将输入的文本查询 query_text 转换为 SQL 查询并执行，返回查询结果。

# 自动修复 SQL 错误
def fix_sql_error(query_text, error):
    prompt = f"之前的 SQL 查询 '{query_text}' 执行出错，错误信息为 '{error}'，请生成正确的 SQL 查询。"
    fixed_query = llm(prompt)
    return fixed_query

解释：定义 fix_sql_error 函数，用于在 SQL 查询执行出错时自动修复。构建一个提示信息 prompt，包含原始查询和错误信息，然后将该提示信息传递给大语言模型 llm，模型会生成修复后的 SQL 查询并返回。

# 查询 agent 主函数
def query_agent(query_text):
    if query_text in memory:
        return memory[query_text]
    conn = connect_to_db()
    if conn:
        try:
            sql_query = text2sql(query_text)
            cursor = conn.cursor()
            cursor.execute(sql_query)
            rows = cursor.fetchall()
            memory[query_text] = rows
            return rows
        except Exception as e:
            print(f"查询错误: {e}，尝试修复 SQL 查询...")
            fixed_query = fix_sql_error(sql_query, str(e))
            try:
                cursor.execute(fixed_query)
                rows = cursor.fetchall()
                memory[query_text] = rows
                return rows
            except Exception as new_e:
                print(f"修复后的 SQL 查询仍出错: {new_e}")
        finally:
            conn.close()
    return []

解释：定义 query_agent 主函数，处理用户的查询请求。首先检查查询文本是否已经存在于 memory 中，若存在则直接返回存储的结果。若不存在，则建立数据库连接，调用 text2sql 函数将文本查询转换为 SQL 查询并执行。若执行出错，调用 fix_sql_error 函数尝试修复查询并再次执行。无论查询是否成功，最后都关闭数据库连接。若最终查询失败，返回空列表。

2. 向量化 Agent（`vectorization_agent.py`）

from langchain.embeddings import OllamaEmbeddings
import pandas as pd

解释：
- from langchain.embeddings import OllamaEmbeddings：从 langchain 库的 embeddings 模块导入 OllamaEmbeddings 类，用于将文本转换为向量表示。
- import pandas as pd：导入 pandas 库，用于数据处理和结构化。

# 加载本地 Ollama 的 DeepSeek 32B 嵌入模型
embeddings = OllamaEmbeddings(model="deepseek-32b")

解释：实例化 OllamaEmbeddings 类，指定加载本地的 deepseek - 32b 嵌入模型，用于将文本转换为向量。

# 结构化数据
def structure_data(data):
    columns = [f"col_{i}" for i in range(len(data[0]))] if data else []
    df = pd.DataFrame(data, columns=columns)
    structured_data = df.to_dict(orient='records')
    return structured_data

解释：定义 structure_data 函数，用于对查询结果进行结构化处理。首先，根据数据的列数生成列名列表 columns。然后，使用 pandas 的 DataFrame 类将数据转换为数据框 df。最后，使用 to_dict 方法将数据框转换为字典列表 structured_data 并返回。

# 向量化 agent 主函数
def vectorization_agent(data):
    structured_data = structure_data(data)
    texts = [str(item) for item in structured_data]
    vectors = embeddings.embed_documents(texts)
    return vectors

解释：定义 vectorization_agent 主函数，实现数据的向量化。首先调用 structure_data 函数对输入数据进行结构化处理，得到结构化数据 structured_data。然后将结构化数据转换为文本列表 texts。最后，调用 embeddings.embed_documents 方法将文本列表转换为向量列表 vectors 并返回。

3. 病例汇总 Agent（`case_summary_agent.py`）

from sklearn.metrics.pairwise import cosine_similarity
from langchain.llms import Ollama

解释：
- from sklearn.metrics.pairwise import cosine_similarity：从 sklearn 库的 metrics.pairwise 模块导入 cosine_similarity 函数，用于计算向量之间的余弦相似度。
- from langchain.llms import Ollama：再次导入 Ollama 类，用于加载和调用大语言模型。

# 加载本地 Ollama 的 DeepSeek 32B 模型
llm = Ollama(model="deepseek-32b")

解释：实例化 Ollama 类，加载本地的 deepseek - 32b 模型，用于病例分析。

# 病例汇总 agent 主函数
def case_summary_agent(vectors, all_vectors, all_cases):
    similarities = []
    for vector in vectors:
        sim = cosine_similarity([vector], all_vectors)
        similarities.append(sim[0])
    similar_cases = []
    for sim in similarities:
        top_indices = sim.argsort()[-5:][::-1]  # 取前 5 个相似病例
        similar_cases.append([all_cases[i] for i in top_indices])
    summary = []
    for cases in similar_cases:
        case_summary = " ".join(cases)
        prompt = f"请对以下病例进行简单分析: {case_summary}"
        analysis = llm(prompt)
        summary.append((case_summary, analysis))
    return summary

解释：定义 case_summary_agent 主函数，用于病例汇总和分析。首先，计算输入向量 vectors 与所有向量 all_vectors 之间的余弦相似度，将结果存储在 similarities 列表中。然后，对于每个相似度列表，找出前 5 个最相似病例的索引，并将对应的病例信息存储在 similar_cases 列表中。接着，对于每个相似病例列表，将病例信息拼接成一个字符串 case_summary，并构建一个提示信息 prompt，请求模型对病例进行简单分析。最后，将病例摘要和分析结果作为元组存储在 summary 列表中并返回。

4. 医疗指导 Agent（`medical_guidance_agent.py`）

from langchain.llms import Ollama

解释：导入 Ollama 类，用于加载和调用大语言模型。

# 加载本地 Ollama 的 DeepSeek 32B 模型
llm = Ollama(model="deepseek-32b")

解释：实例化 Ollama 类，加载本地的 deepseek - 32b 模型，用于生成医疗指导意见。

# 医疗指导 agent 主函数
def medical_guidance_agent(summary):
    guidance = []
    for case_summary, _ in summary:
        prompt = f"根据以下病例汇总，给出诊断治疗意见: {case_summary}"
        advice = llm(prompt)
        guidance.append(advice)
    return guidance

解释：定义 medical_guidance_agent 主函数，用于生成医疗指导意见。遍历病例汇总信息 summary，对于每个病例摘要，构建一个提示信息 prompt，请求模型根据病例汇总给出诊断治疗意见。将模型生成的意见存储在 guidance 列表中并返回。

5. 预后预测 Agent（`prognosis_prediction_agent.py`）

from langchain.llms import Ollama

解释：导入 Ollama 类，用于加载和调用大语言模型。

# 加载本地 Ollama 的 DeepSeek 32B 模型
llm = Ollama(model="deepseek-32b")

解释：实例化 Ollama 类，加载本地的 deepseek - 32b 模型，用于预后预测。

# 预后预测 agent 主函数
def prognosis_prediction_agent(summary):
    predictions = []
    for case_summary, _ in summary:
        prompt = f"根据以下相似病例，推测目前病历进展与预后: {case_summary}"
        prediction = llm(prompt)
        predictions.append(prediction)
    return predictions

解释：定义 prognosis_prediction_agent 主函数，用于预后预测。遍历病例汇总信息 summary，对于每个病例摘要，构建一个提示信息 prompt，请求模型根据相似病例推测目前病历的进展与预后。将模型生成的预测结果存储在 predictions 列表中并返回。

总结

通过以上详细的代码解释，我们可以看到这个多 Agent 架构的医疗病历处理系统是如何协同工作的。从查询病历信息到向量化、病例汇总、医疗指导和预后预测，每个 Agent 都承担着特定的任务，利用大语言模型的强大能力实现了对医疗病历的有效处理和分析。这种架构不仅提高了医疗数据处理的效率，还为医疗决策提供了有力的支持。

#Python #多 Agent 架构 #医疗病历处理 #DeepSeek32B #Ollama