俊瑶先森

from langchain.tools import tool

@tool
def get_exchange_rate(currency: str) -> str:
    """
    获取货币汇率信息
    
    这个工具用于查询指定货币对人民币的汇率。
    在实际应用中，这里可以对接真实的汇率 API（如 ExchangeRate-API）。
    
    Args:
        currency: 货币代码，例如"USD"（美元）、"EUR"（欧元）
    
    Returns:
        返回格式化的汇率信息字符串
    """
    # 简单的汇率数据映射表（实际应用中应该从汇率API获取）
    if currency == "USD" or currency == "美元":
        return "美元对人民币汇率：1 USD = 7.25 CNY"
    if currency == "EUR" or currency == "欧元":
        return "欧元对人民币汇率：1 EUR = 7.85 CNY"
    return f"没有找到{currency}的汇率信息"

@tool
def calculate(expression: str) -> str:
    """
    计算表达式
    
    这个工具用于执行数学表达式计算。
    注意：实际生产环境中应该使用更安全的表达式解析库（如 numexpr），
    而不是直接使用 eval()，这里仅用于演示。
    
    Args:
        expression: 数学表达式字符串，例如"100 * 7.25"
    
    Returns:
        计算结果字符串
    """
    # 使用 eval 计算表达式（仅用于演示，生产环境需更安全的方案）
    return str(eval(expression))

# 定义工具列表，用于绑定到 LLM
# LLM 可以根据工具描述自动决定何时调用哪个工具
TOOLS = [get_exchange_rate, calculate]

# 创建工具字典，key 为工具名称，value 为工具对象
# 在执行工具调用时，通过工具名称快速查找对应的工具对象
TOOL_DICT = {tool.name: tool for tool in TOOLS}

from langchain_openai import ChatOpenAI
import os

# 创建 DeepSeek 模型实例
# 使用 ChatOpenAI 类是因为 DeepSeek 兼容 OpenAI API 格式
LLM = ChatOpenAI(
    model="deepseek-chat",  # 指定模型名称
    api_key=os.getenv("DEEPSEEK_API_KEY"),  # 从环境变量读取 API Key
    base_url=os.getenv("DEEPSEEK_BASE_URL"),  # DeepSeek 的 API 基础地址
)

# 将 LLM 与工具列表绑定
# bind_tools() 方法会将工具的描述信息注入到模型的上下文中
# 这样模型在生成回复时，可以识别何时需要调用工具，并生成相应的工具调用请求
LLM_WITH_TOOLS = LLM.bind_tools(TOOLS)

from langgraph.graph.message import MessagesState

class PlanAndExecuteState(MessagesState):
    """
    计划和执行状态定义
    
    这个状态类用于在整个 Agent 执行过程中保存和传递信息。
    
    继承自 MessagesState 的属性：
        messages: List[BaseMessage] - 消息列表，包含对话历史、工具调用等
    
    自定义属性：
        plan: str - 生成的执行计划文本
        step: int - 当前执行的步骤编号（从 0 开始）
    """

    plan: str  # 生成的计划，由 plan_node 生成并保存
    step: int  # 当前步骤，每次执行后递增，用于跟踪执行进度

from state import PlanAndExecuteState
from llm import LLM_WITH_TOOLS
from langchain_core.messages import SystemMessage

# 生成计划的 System Prompt
# 这个提示词指导 LLM 如何生成执行计划
SYSTEM_PROMPT = """
你是一位智能助手，擅长解决用户提出的各种问题。请为用户提出的问题创建分析方案步骤。

如果有需要，可以调用工具。

你可以调用工具的列表如下：
get_exchange_rate:
    获取指定货币对人民币的汇率信息
    Parameters:
    -----------
    currency : str
        货币代码，例如"USD"（美元）、"EUR"（欧元）
    Returns:
    --------
    str
        指定货币的汇率信息

calculate:
    计算表达式
    Parameters:
    -----------
    expression : str
        表达式内容
    Returns:
    --------
    str
        表达式的计算结果

要求：
1.用中文列出清晰步骤
2.每个步骤标记序号
3.明确说明需要分析和执行的内容
4.只需输出计划内容，不要做任何额外的解释和说明
5.设计的方案步骤要紧紧贴合我的工具所能返回的内容，不要超出工具返回的内容
"""

def plan_node(state: PlanAndExecuteState) -> PlanAndExecuteState:
    """
    生成计划节点
    
    这个节点的职责：
    1. 接收用户的问题（在 state["messages"] 中）
    2. 调用 LLM 生成执行计划
    3. 将计划保存到状态中，供后续节点使用
    
    Args:
        state: 当前状态，包含用户消息
    
    Returns:
        更新后的状态，包含生成的计划
    """
    
    # 构造消息列表
    # SystemMessage 放在最前面，用于设置 LLM 的角色和行为
    # state["messages"] 包含用户的问题
    messages = [SystemMessage(content=SYSTEM_PROMPT)] + state["messages"]
    
    # 调用 LLM 生成计划
    # invoke() 方法会发送消息到 LLM，并返回回复
    # .content 获取回复的文本内容（计划文本）
    response = LLM_WITH_TOOLS.invoke(input=messages)
    plan = response.content
    print(f"生成的计划: \n{plan}")
    
    # 更新状态，保存生成的计划
    # 这个计划将在 execute_node 中被使用
    state["plan"] = plan
    
    # 返回更新后的状态
    # LangGraph 会将这个状态传递给下一个节点
    return state

from state import PlanAndExecuteState
from llm import LLM_WITH_TOOLS
from langchain_core.messages import SystemMessage

# 执行计划的 System Prompt
# 这个提示词指导 LLM 如何执行计划中的步骤
SYSTEM_PROMPT = """
你是一位思路清晰、有条理的智能助手，你必须严格按照以下计划执行任务：

当前计划：

{plan}

如果你认为计划已经执行到最后一步了，请在内容的末尾加上 Final Answer 字样
示例：
这个问题的最终答案是99.99。
Final Answer
"""

def execute_node(state: PlanAndExecuteState) -> PlanAndExecuteState:
    """
    执行计划节点
    
    这个节点的职责：
    1. 读取计划节点生成的计划
    2. 根据计划、对话历史和工具调用结果，执行当前步骤
    3. LLM 可能直接回复，也可能生成工具调用请求
    4. 更新执行步骤计数器
    
    Args:
        state: 当前状态，包含计划、消息历史和步骤编号
    
    Returns:
        更新后的状态，包含执行结果
    """
    
    # 获取当前步骤编号
    # 用于跟踪执行进度和日志输出
    step = state["step"]
    
    # 构造消息列表
    # SystemMessage 包含当前计划，指导 LLM 执行
    # state["messages"] 包含完整的对话历史（用户消息、AI回复、工具调用结果等）
    system_message = SystemMessage(content=SYSTEM_PROMPT.format(plan=state["plan"]))
    messages = [system_message] + state["messages"]
    
    # 调用 LLM 执行计划
    # LLM 会分析当前状态，决定下一步操作
    # 如果 LLM 认为需要调用工具，会在 resp.tool_calls 中返回工具调用信息
    # 如果 LLM 认为可以直接回复，会在 resp.content 中返回文本内容
    resp = LLM_WITH_TOOLS.invoke(input=messages)
    print(f"\n【第 {step + 1} 步】{resp.content}")
    
    # 更新状态
    # 1. 将 LLM 的回复添加到消息历史中
    # 2. 递增步骤计数器
    state["messages"].append(resp)
    state["step"] = step + 1
    
    # 返回更新后的状态
    # 后续的条件边会根据 resp 的内容决定下一步流向
    return state

from state import PlanAndExecuteState
from tools import TOOL_DICT
from langchain_core.messages import ToolMessage

def tool_node(state: PlanAndExecuteState) -> PlanAndExecuteState:
    """
    工具调用节点
    
    这个节点的职责：
    1. 从最后一条消息中提取工具调用信息
    2. 根据工具名称查找对应的工具对象
    3. 使用工具参数执行工具调用
    4. 将工具调用结果封装为 ToolMessage，添加到消息历史中
    
    Args:
        state: 当前状态，最后一条消息应包含 tool_calls
    
    Returns:
        更新后的状态，包含工具调用结果
    """
    
    # 获取最后一条消息中的工具调用信息
    # 最后一条消息应该是 execute_node 中 LLM 生成的回复
    # 如果 LLM 决定调用工具，这条消息会包含 tool_calls 字段
    last_message = state["messages"][-1]
    tool_calls = last_message.tool_calls
    
    # 如果没有工具调用，直接返回（理论上不应该发生，因为只有有工具调用才会进入此节点）
    if tool_calls is None:
        return state
    
    # 遍历所有工具调用（LLM 可能同时调用多个工具）
    for tool_call in tool_calls:
        # 提取工具名称和参数
        # tool_call 是一个字典，包含：
        #   - "name": 工具名称，如 "get_exchange_rate"
        #   - "args": 工具参数字典，如 {"currency": "USD"}
        #   - "id": 工具调用 ID，用于关联 ToolMessage
        tool_name = tool_call["name"]
        tool_args = tool_call["args"]
        
        # 从工具字典中查找对应的工具对象
        tool = TOOL_DICT.get(tool_name)
        if tool is None:
            # 如果找不到工具，跳过（实际应用中应该记录错误）
            continue
        
        # 执行工具调用
        # invoke() 方法会使用 tool_args 调用工具函数
        # 例如：get_exchange_rate.invoke({"currency": "USD"}) -> "美元对人民币汇率：1 USD = 7.25 CNY"
        tool_call_result = tool.invoke(input=tool_args)
        print(f"\n调用工具: {tool_name}\n参数: {tool_args}\n执行结果: {tool_call_result}")
        
        # 将工具调用结果封装为 ToolMessage，添加到消息历史中
        # ToolMessage 需要包含 tool_call_id，用于关联对应的工具调用请求
        # 这样 LLM 在后续回复时，可以知道哪个工具调用产生了哪个结果
        state["messages"].append(
            ToolMessage(
                content=f"工具调用结果: {tool_call_result}",
                tool_call_id=tool_call["id"],  # 关联工具调用请求
            )
        )
    
    # 返回更新后的状态
    # 状态中现在包含了工具调用结果，流程会回到 execute_node 继续执行
    return state

from state import PlanAndExecuteState
from langgraph.graph import END

def conditional_edge(state: PlanAndExecuteState) -> str:
    """
    条件边函数
    
    这个函数决定 execute_node 执行后的下一步流向：
    - 如果 LLM 回复中包含 "Final Answer"，返回 END，表示任务完成
    - 否则返回 "tool_node"，表示需要调用工具
    
    Args:
        state: 当前状态，包含执行结果
    
    Returns:
        下一个节点的名称，或 END 表示结束
    """
    
    # 获取最后一条消息（应该是 execute_node 中 LLM 的回复）
    last_message = state["messages"][-1]
    
    # 检查回复中是否包含 "Final Answer" 标识
    # 这是我们在 execute_node 的 System Prompt 中要求的终止条件
    if "Final Answer" in last_message.content:
        # 如果包含，返回 END，表示任务完成，流程结束
        return END
    else:
        # 如果不包含，返回 "tool_node"，表示需要调用工具
        # 注意：这里假设 LLM 的回复一定包含 tool_calls
        # 实际应用中可能需要更复杂的判断逻辑
        return "tool_node"

from langgraph.graph import StateGraph, START, END
from langgraph.graph.state import CompiledStateGraph
from langchain_core.messages import HumanMessage

def build_agent() -> CompiledStateGraph:
    """
    构建 Plan-and-Execute Agent
    
    这个函数负责：
    1. 创建状态图（StateGraph）
    2. 添加所有节点
    3. 添加节点之间的边（普通边和条件边）
    4. 编译成可执行的 Agent
    
    Returns:
        编译后的 Agent，可以用于执行任务
    """
    
    # 创建状态图，指定状态类型为 PlanAndExecuteState
    # StateGraph 是 LangGraph 的核心类，用于构建有状态的工作流
    graph = StateGraph(PlanAndExecuteState)
    
    # 添加节点
    # add_node() 方法将节点函数注册到图中
    # 第一个参数是节点名称（字符串），第二个参数是节点函数
    graph.add_node("plan_node", plan_node)      # 计划节点
    graph.add_node("execute_node", execute_node)  # 执行节点
    graph.add_node("tool_node", tool_node)      # 工具节点
    
    # 添加普通边（无条件流转）
    # START 是 LangGraph 的特殊节点，表示工作流的起始点
    graph.add_edge(START, "plan_node")          # 从起始点进入计划节点
    graph.add_edge("plan_node", "execute_node")  # 计划节点执行完后进入执行节点
    
    # 添加条件边（根据条件决定流转方向）
    # add_conditional_edges() 用于添加条件分支
    graph.add_conditional_edges(
        source="execute_node",              # 源节点：执行节点
        path=conditional_edge,              # 条件判断函数
        path_map={                          # 路径映射：条件函数的返回值 -> 目标节点
            "tool_node": "tool_node",      # 如果返回 "tool_node"，进入工具节点
            END: END,                       # 如果返回 END，流程结束
        },
    )
    
    # 添加普通边：工具节点执行完后，回到执行节点继续执行
    # 这样就形成了一个循环：execute_node -> tool_node -> execute_node
    graph.add_edge("tool_node", "execute_node")
    
    # 编译 Agent
    # compile() 方法会将图编译成可执行的状态机
    # 编译后的 Agent 可以接收初始状态并执行整个工作流
    agent = graph.compile()
    
    # 可选：打印 Agent 节点结构图，并保存到本地
    # 这有助于可视化工作流的执行流程
    agent.get_graph().draw_mermaid_png(output_file_path="./agent.png")
    
    # 返回编译后的 Agent
    return agent

def run_agent(agent: CompiledStateGraph, user_query: str) -> str:  
    """
    运行 Agent
    
    这个函数负责：
    1. 初始化 Agent 状态
    2. 执行 Agent 工作流
    3. 返回最终结果
    
    Args:
        agent: 编译后的 Agent 实例
        user_query: 用户的问题
    
    Returns:
        最终的回答文本
    """
    
    # 初始化状态
    # 创建用户消息，包含用户的问题
    messages = [HumanMessage(content=user_query)]
    
    # 创建初始状态对象
    # plan 初始化为空字符串，将在 plan_node 中生成
    # step 初始化为 0，表示还未开始执行
    # messages 包含用户的问题
    init_state = PlanAndExecuteState(
        plan="",           # 计划初始为空
        step=0,            # 步骤从 0 开始
        messages=messages, # 包含用户消息
    )
    
    # 运行 Agent
    # invoke() 方法会从 START 节点开始执行，直到遇到 END
    # 执行过程中，状态会在节点之间传递和更新
    result = agent.invoke(init_state)
    
    # 返回最终结果
    # 最后一条消息应该是包含 "Final Answer" 的回复
    return result["messages"][-1].content

if __name__ == "__main__":
    
    # 构建 Agent
    # 创建并编译整个工作流图
    agent: CompiledStateGraph = build_agent()
    
    # 运行 Agent，传入用户问题
    # Agent 会按照 Plan-and-Execute 模式执行：
    # 1. 生成计划（如：查询美元汇率、查询欧元汇率、计算总兑换金额）
    # 2. 执行计划（调用工具获取汇率信息）
    # 3. 计算并返回最终答案
    result = run_agent(agent, "我想用100美元和50欧元兑换人民币，总共能兑换多少人民币？")
    print(f"\n最终答案: {result}")

import os
import operator
from typing import Literal
from dotenv import load_dotenv

from langchain.tools import tool
from langchain.chat_models import init_chat_model
from langchain.messages import AnyMessage, SystemMessage, ToolMessage, HumanMessage
from typing_extensions import TypedDict, Annotated
from langgraph.graph import StateGraph, START, END

# 加载 .env 文件中的环境变量
load_dotenv()

# 配置自建模型（必须从 .env 文件中读取）
BASE_URL = os.getenv("OPENAI_BASE_URL")
API_KEY = os.getenv("OPENAI_API_KEY")
MODEL_NAME = os.getenv("OPENAI_MODEL")

# 检查必需的配置项是否存在
if not BASE_URL:
    raise ValueError("OPENAI_BASE_URL 未在 .env 文件中配置")
if not API_KEY:
    raise ValueError("OPENAI_API_KEY 未在 .env 文件中配置")
if not MODEL_NAME:
    raise ValueError("OPENAI_MODEL 未在 .env 文件中配置")

model = init_chat_model(
    model=MODEL_NAME,  # 自建模型直接使用模型名称，不需要 openai: 前缀
    model_provider="openai",
    temperature=0.7,
    base_url=BASE_URL,
    api_key=API_KEY,
)


# 定义工具
@tool
def multiply(a: int, b: int) -> int:
    """Multiply `a` and `b`.

    Args:
        a: First int
        b: Second int
    """
    return a * b


@tool
def add(a: int, b: int) -> int:
    """Adds `a` and `b`.

    Args:
        a: First int
        b: Second int
    """
    return a + b


@tool
def divide(a: int, b: int) -> float:
    """Divide `a` and `b`.

    Args:
        a: First int
        b: Second int
    """
    return a / b


# 为LLM添加工具
tools = [add, multiply, divide]
tools_by_name = {tool.name: tool for tool in tools}
model_with_tools = model.bind_tools(tools)


# 步骤2：定义状态
class MessagesState(TypedDict):
    messages: Annotated[list[AnyMessage], operator.add]
    llm_calls: int


# 步骤3：定义模型节点
def llm_call(state: dict):
    """LLM decides whether to call a tool or not"""
    return {
        "messages": [
            model_with_tools.invoke(
                [
                    SystemMessage(
                        content="You are a helpful assistant tasked with performing arithmetic on a set of inputs."
                    )
                ]
                + state["messages"]
            )
        ],
        "llm_calls": state.get('llm_calls', 0) + 1
    }


# 步骤4：定义工具节点
def tool_node(state: dict):
    """Performs the tool call"""
    result = []
    for tool_call in state["messages"][-1].tool_calls:
        tool = tools_by_name[tool_call["name"]]
        observation = tool.invoke(tool_call["args"])
        result.append(ToolMessage(content=str(observation), tool_call_id=tool_call["id"]))
    return {"messages": result}


# 步骤5：定义结束逻辑
def should_continue(state: MessagesState) -> Literal["tool_node", END]:
    """Decide if we should continue the loop or stop based upon whether the LLM made a tool call"""
    messages = state["messages"]
    last_message = messages[-1]

    # If the LLM makes a tool call, then perform an action
    if last_message.tool_calls:
        return "tool_node"

    # Otherwise, we stop (reply to the user)
    return END


# 步骤6：构建并编译代理
# 构建工作流
agent_builder = StateGraph(MessagesState)

# 添加节点
agent_builder.add_node("llm_call", llm_call)
agent_builder.add_node("tool_node", tool_node)

# 添加边以连接节点
agent_builder.add_edge(START, "llm_call")
agent_builder.add_conditional_edges(
    "llm_call",
    should_continue,
    ["tool_node", END]
)
agent_builder.add_edge("tool_node", "llm_call")

# 编译代理
agent = agent_builder.compile()


# 示例用法
if __name__ == "__main__":
    print("=== LangGraph Calculator Agent Demo ===\n")
    
    # 测试用例1：加法
    print("Test 1: Add 3 and 4")
    messages = [HumanMessage(content="Add 3 and 4.")]
    result = agent.invoke({"messages": messages})
    print(f"LLM calls: {result.get('llm_calls', 0)}")
    for m in result["messages"]:
        print(f"- {m.__class__.__name__}: {m.content}")
    print("\n")
    
    # 测试用例2：乘法
    print("Test 2: Multiply 5 and 6")
    messages = [HumanMessage(content="Multiply 5 and 6.")]
    result = agent.invoke({"messages": messages})
    print(f"LLM calls: {result.get('llm_calls', 0)}")
    for m in result["messages"]:
        print(f"- {m.__class__.__name__}: {m.content}")
    print("\n")
    
    # 测试用例3：除法
    print("Test 3: Divide 20 by 4")
    messages = [HumanMessage(content="Divide 20 by 4.")]
    result = agent.invoke({"messages": messages})
    print(f"LLM calls: {result.get('llm_calls', 0)}")
    for m in result["messages"]:
        print(f"- {m.__class__.__name__}: {m.content}")
    print("\n")
    
    # 测试用例4：复杂计算
    print("Test 4: Add 10 and 5, then multiply the result by 3")
    messages = [HumanMessage(content="Add 10 and 5, then multiply the result by 3.")]
    result = agent.invoke({"messages": messages})
    print(f"LLM calls: {result.get('llm_calls', 0)}")
    for m in result["messages"]:
        print(f"- {m.__class__.__name__}: {m.content}")

load_dotenv()  # 加载 .env 文件中的环境变量
BASE_URL = os.getenv("OPENAI_BASE_URL")
API_KEY = os.getenv("OPENAI_API_KEY")
MODEL_NAME = os.getenv("OPENAI_MODEL")

@tool
def multiply(a: int, b: int) -> int:
    """Multiply `a` and `b`."""
    return a * b

class MessagesState(TypedDict):
    messages: Annotated[list[AnyMessage], operator.add]
    llm_calls: int

def llm_call(state: dict):
    return {
        "messages": [
            model_with_tools.invoke([
                SystemMessage(content="...")] + state["messages"]
            )
        ],
        "llm_calls": state.get('llm_calls', 0) + 1
    }

def tool_node(state: dict):
    result = []
    for tool_call in state["messages"][-1].tool_calls:
        tool = tools_by_name[tool_call["name"]]
        observation = tool.invoke(tool_call["args"])
        result.append(ToolMessage(...))
    return {"messages": result}

def should_continue(state: MessagesState) -> Literal["tool_node", END]:
    last_message = messages[-1]
    if last_message.tool_calls:
        return "tool_node"  # 有工具调用，去执行工具
    return END  # 没有工具调用，结束流程

agent_builder = StateGraph(MessagesState)
agent_builder.add_node("llm_call", llm_call)
agent_builder.add_node("tool_node", tool_node)
agent_builder.add_edge(START, "llm_call")
agent_builder.add_conditional_edges("llm_call", should_continue, ["tool_node", END])
agent_builder.add_edge("tool_node", "llm_call")
agent = agent_builder.compile()

load_dotenv()  # 加载 .env 文件中的环境变量
BASE_URL = os.getenv("OPENAI_BASE_URL")
API_KEY = os.getenv("OPENAI_API_KEY")
MODEL_NAME = os.getenv("OPENAI_MODEL")

@tool
def multiply(a: int, b: int) -> int:
    """Multiply `a` and `b`."""
    return a * b

class MessagesState(TypedDict):
    messages: Annotated[list[AnyMessage], operator.add]
    llm_calls: int

def llm_call(state: dict):
    return {
        "messages": [
            model_with_tools.invoke([
                SystemMessage(content="...")] + state["messages"]
            )
        ],
        "llm_calls": state.get('llm_calls', 0) + 1
    }

def tool_node(state: dict):
    result = []
    for tool_call in state["messages"][-1].tool_calls:
        tool = tools_by_name[tool_call["name"]]
        observation = tool.invoke(tool_call["args"])
        result.append(ToolMessage(...))
    return {"messages": result}

def should_continue(state: MessagesState) -> Literal["tool_node", END]:
    last_message = messages[-1]
    if last_message.tool_calls:
        return "tool_node"  # 有工具调用，去执行工具
    return END  # 没有工具调用，结束流程

agent_builder = StateGraph(MessagesState)
agent_builder.add_node("llm_call", llm_call)
agent_builder.add_node("tool_node", tool_node)
agent_builder.add_edge(START, "llm_call")
agent_builder.add_conditional_edges("llm_call", should_continue, ["tool_node", END])
agent_builder.add_edge("tool_node", "llm_call")
agent = agent_builder.compile()

# -*- coding: utf-8 -*-
from pydantic import BaseModel, Field
from typing import List, Optional
from langchain.agents import create_agent
import json
import os

# 定义产品信息输出结构
class ProductInfo(BaseModel):
    name: Optional[str] = Field(description="产品名称")
    catalog_number: Optional[str] = Field(description="规格货号")
    description: Optional[str] = Field(description="产品描述")
    validity_period: Optional[str] = Field(description="有效期")
    storage_temperature: Optional[str] = Field(description="保存温度")

# 设置环境变量（推荐方式）
os.environ["OPENAI_API_BASE"] = "https://{HOST}/v1"
os.environ["OPENAI_API_KEY"] = "sk-XXX"

# 创建代理 - 使用环境变量配置
agent = create_agent(
    model="openai:XXXX",
    tools=[],  # 可以添加工具，这里暂时为空
    response_format=ProductInfo  # Auto-selects ProviderStrategy
)

def extract_product_info(text: str) -> ProductInfo:
    """从文本中提取产品结构化信息"""
    
    try:
        # 使用 langchain agent 进行结构化提取
        result = agent.invoke({
            "messages": [{"role": "user", "content": f"""
请从以下产品说明书中提取结构化信息：

文本内容：
{text}

请提取以下信息：
1. 产品名称
2. 规格货号（产品编号）
3. 产品描述
4. 有效期
5. 保存温度
6. 注意事项列表

请严格按照ProductInfo模型的结构返回结果。
"""}]
        })
        
        # 返回结构化响应
        return result["structured_response"]
            
    except Exception as e:
        print(f"API调用失败: {e}")
        # 返回一个默认的产品信息对象
        return ProductInfo(
            name="提取失败",
            catalog_number="未知",
            description="无法提取产品描述",
            validity_period="未知",
            storage_temperature="未知",
            precautions=["提取过程中出现错误"]
        )

# 示例文本
sample_text = """
## 达优

## Mouse IL-22 Precoated ELISA Kit

Cat#:1212202/1212203

ELISA 试剂盒 说明书

本试剂盒仅供科研使用，请勿用于诊断 使用前请仔细阅读说明书并检查试剂盒组分
## Mouse IL-22

## Precoated ELISA Kit

ELISA试剂盒

## | 检测原理

达优ELISA 试剂盒采用双抗体夹心酶联免疫吸附检测技术。特异性的抗体包 被到酶标板上，标准品或样本加入孔中，样本中含有的目标物质被固定化的抗体 捕获，加入检测抗体，形成抗体-抗原-抗体的复合体，加入酶和底物，在酶的催 化下底物发生反应，且反应的颜色与目标物质的含量成正比，加入终止液后，在 酶标仪中测定反应的吸光值。

## | 预期用途

定量检测血清、血浆、缓冲液或细胞培养液中的IL-22含量。

## | 知识背景

白细胞介素22（Interleukin-22, IL-22）又称白细胞介素 10 相关 T 细胞衍 生诱导因子，与IL-10，IL-19，IL-20，IL-24 和 IL-26 同属于 IL-10 调节性细胞 因子。 它主要由Th22 细胞分泌， IL-23 和 IL-6 可直接刺激初始 T 细胞产生 IL-22， 某些NK细胞也可以产生IL-22。其次，IL-22以皮肤，胰腺，肝脏等组织细胞为 主要靶细胞，调节这些组织细胞的功能，它在感染免疫，组织修复、肝炎产生和 肝癌形成中起重要作用。

## | 保存条件

未开封试剂盒在2℃～8℃可稳定保存12个月。

## 开封后各组分保存条件见下：

## Cat#:1212202

| 组分                     | 规格    | 数量   | 保存条件                                 |
|------------------------|-------|------|--------------------------------------|
| Cytokine Standard      |       | 2瓶   | 48 T 复溶后-25℃～-15℃保存15天，分装保 存，不可重复冻融。 |
| Biotinylated Antibody  | μL    | 2管   | 50 原液2℃～8℃可稳定保存1个月，稀释 后不可保存。         |
| Streptavidin-HRP       | 50 μL | 2管   | 原液2℃～8℃可稳定保存1个月，稀释 后不可保存。            |
| Dilution Buffer R (1×) | 10 mL | 3瓶   | 2℃～8℃可稳定保存1个月。                       |
| Washing Buffer (50×)   | 15 mL | 1瓶   | 原液2℃～8℃可稳定保存1个月，稀释 后不可保存。            |
| TMB                    | 10 mL | 1瓶   | 2℃～8℃可稳定保存1个月。                       |
| Stop Solution          | 10 mL | 1瓶   | 2℃～8℃可稳定保存1个月。                       |
| Precoated ELISA plate  | 96 T  | 1块   | 2℃～8℃可稳定保存1个月，密封保存。                  |
| 封板膜                    | /     |      | 4张 /                                 |
| 说明书                    | /     | 1份   | /                                    |

Cat#:1212203

| 组分                      | 规格     | 数量   | 保存条件                             |
|-------------------------|--------|------|----------------------------------|
| Cytokine Standard       | 48 T   | 10瓶  | 复溶后-25℃～-15℃保存15天， 分装 保存，不可重复冻融。 |
| Biotinylated Antibody   | 50 μL  | 10管  | 原液2℃～8℃可稳定保存1个月，稀 释后不可保存。        |
| Streptavidin-HRP        | 500 μL | 1管   | 原液2℃～8℃可稳定保存1个月，稀 释后不可保存。        |
| Dilution Buffer R (10×) | 18 mL  | 1瓶   | 2℃～8℃可稳定保存1个月。                   |
| Washing Buffer (50×)    | 75 mL  | 1瓶   | 原液2℃～8℃可稳定保存1个月，稀 释后不可保存。        |
| TMB                     | 50 mL  | 1瓶   | 2℃～8℃可稳定保存1个月。                   |
| Stop Solution           | 50 mL  | 1瓶   | 2℃～8℃可稳定保存1个月。                   |
| Precoated ELISA plate   | 96 T   | 5块   | 2℃～8℃可稳定保存1个月，密封保 存。             |
| 封板膜                     | /      | 20张  | /                                |
| 说明书                     | /      | 1份   | /                                |

## | 需自备的材料设备

+ 能够检测450nm和630nm吸光度的酶标仪
+ 微量加液器及枪头、加样槽
+ 蒸馏水或去离子水
+ 旋涡振荡器或磁力搅拌器

## | 注意事项

1. 试剂按标签和说明书储存，使用前平衡至室温。
2. 标准品按照标签溶解，充分混匀，按照一次使用量分装保存。
3. 预包被板条使用前平衡至室温；剩余板条及时密封保存。
4. Washing Buffer (50×)在 2℃～8℃保存可能有结晶析出，若有析出加热或 平衡温度使其溶解后再使用。
5. 离心管试剂体积量较小，使用前高速短暂离心收集试剂到管底。
6. 实验操作中请使用一次性的吸头，避免交叉污染。
7. 使用前检查试剂盒内各种试剂；试剂稀释及加样时注意混匀试剂。
8. 实验板孔加入试剂的顺序应一致，以保证所有反应孔的孵育时间一致。
9. 使用干净的容器配制试剂。
10. 洗涤后孔中残留的洗涤液应在吸水纸上充分拍干，直至吸水纸上看不到 水印。请勿直接将孔中的洗涤液吸干。
11. TMB 对光和金属敏感，避免长时间暴露于光下，避免与金属接触。未使 用的TMB若变为蓝色，表明TMB已经污染，请丢弃。
12. 请严格按照说明书建议的反应时间和温度进行孵育。 冬季室内温度偏低， 建议使用恒温箱或培养箱孵育。
13. 请在保质期内使用试剂盒，且不同批号试剂不要混用。
14. 200 pg/mL 以上的结果为非线性的，根据此标准曲线无法得到精确的结
果。大于200pg/mLIL-22 的样本应稀释后重新测试。在结果分析时，结合考虑 相应的稀释度。

15. 安全提示： 使用本试剂盒时请做好合适的防护措施，如穿戴白大褂、乳 胶手套、安全眼镜等；避免试剂接触皮肤和眼睛，如不慎接触，立即用大量清水 清洗。
16. 废弃处置： 终止液使用碱性溶液中和或稀释后，再用大量水冲入废水系 统。其他成分按一般废弃物处理方法和当地相关法规的要求进行处理。

## | 样本处理说明

新鲜标本尽早检测，对收集后当天就进行检测的标本，及时储存2℃～8℃。 如有特殊原因需要周期性收集标本，请在取材后，将标本及时分装并放在-25℃ ～-15℃或更低温度条件下保存，避免反复冻融。

+ 血清*： 室温血液自然凝固10～20分钟后，离心20分钟（2000～3000 转/分），仔细收集上清。保存过程中如有沉淀形成，应再次离心取上清。
+ 血浆*： 应根据标本的要求选择EDTA、柠檬酸钠或肝素作为抗凝剂，混 合10～20 分钟后，离心 20 分钟（2000～3000 转/分），仔细收集上清。保存过 程中如有沉淀形成，应再次离心。
+ 细胞培养上清： 检测分泌性的成份时，请用无菌管收集细胞培养悬液， 离心20分钟（2000～3000 转/分），仔细收集上清。检测细胞内的成份时，用 1×PBS（pH 7.2～7.4）将细胞悬液稀释至 10 6 cell/mL 左右，反复冻融，以使细 胞破碎释放细胞内成份，离心20分钟（2000～3000转/分），仔细收集上清。 细胞培养上清保存过程中如有沉淀形成，应再次离心。

* 血浆血清样本检测之前需用DilutionBufferR(1×)至少稀释 2 倍后检测， 以降低样本 基质效应。具体稀释倍数需预实验确定。


## | 试剂的配制

1. 提前20分钟将Washing Buffer(50×)和即用溶液从试剂盒中取出，平衡 至室温。
2. 需稀释配制成工作液的试剂现配现用。
3. Cytokine Standard：先按标签说明将冻干粉溶解，溶解后的浓度为 200 pg/mL，再用 1×Dilution Buffer R (1×)进行倍比稀释。稀释前将标准品轻轻 振荡5分钟。
+ 推荐标准品浓度梯度为： 200 pg/mL、100 pg/mL、50 pg/mL、 25 pg/mL、12.5 pg/mL、6.25 pg/mL、3.13 pg/mL，为确保标准品稀释的准 确性，建议在实验孔外进行标准品的倍比稀释。
+ 稀释步骤： 校准品按瓶标签进行溶解后移入EP管中，标记为C7。再取 6 个 EP 管，分别标记为 C6/C5/C4/C3/C2/C1，每个管中加 250 μL 稀释液，从 C7 中取出 250 μL 高浓度校准品至 C6 管中进行 2 倍倍比稀释，以同样方式稀释 C5/C4/C3/C2/C1 管中，以稀释液作为 C0。
4. Biotinylated Antibody：1:100 用 Dilution Buffer R (1×)稀释，混匀制 成Biotinylated Antibody 工作液。
5. Streptavidin-HRP：1:100 用 Dilution Buffer R (1×)稀释，混匀制成 Streptavidin-HRP 工作液。
6. Washing Buffer (50×)：1:50 用蒸馏水稀释。
7. *Dilution Buffer R (10×)： 1:9 用 1×PBS （pH=7.2～7.4） 配制成 1×Dilution Buffer R 工作液，只用于稀释 Cytokine Standard、Biotinylated Antibody、 Streptavidin-HRP 和样品

*此步骤适用于Cat#:1212203 试剂盒，Cat#:1212202 中本试剂为 1×工作液，无需 稀释。


## | 即用型试剂

+ Dilution Buffer R (1×)：用于稀释 Cytokine Standard、样本、 Biotinylated Antibody 和 Streptavidin-HRP。
+ TMB
+ Stop Solution


## | 操作过程

1. 使用前，将所有试剂充分混匀，避免产生泡沫。
2. 根据实验孔（空白和标准品）数量，确定所需的板条数目。样本（含标准 品）和空白都应做复孔。
3. 加样： 100 μL/well 加入稀释后的 Cytokine Standard 至标准品孔， 100 μL/well 加入样本至样本孔， 100 μL/well 加入 Dilution Buffer R (1×)至空 白对照孔，37℃孵育90分钟。
4. 洗板： 扣去孔内液体，300 μL/well 加入 1×Washing Buffer 工作液；停 留1分钟后弃去孔内液体。重复4次，每一次在滤纸上扣干。
5. 加检测抗体 ：100 μL/well 加入 Biotinylated Antibody 工作液。混匀后 盖上封板膜，37℃孵育60分钟。
6. 洗板：重复步骤4。
7. 加酶： 100 μL/well 加入 Streptavidin-HRP 工作液。盖上封板膜，37℃ 孵育30分钟。
8. 洗板：重复步骤4。
9. 显色： 100 μL/well 加入 TMB，37℃避光孵育 10～20 分钟。可根据孔内 颜色的深浅判断，校准曲线最高值孔为深蓝色，空白孔无明显蓝色时即可终止反 应。
10. 终止反应： 100 μL/well 迅速加入 Stop Solution 终止反应。
11. 读板： 终止反应10分钟内在酶标仪进行双波长读板，设置检测波长 450 nm 和参考波长 610 nm～630 nm；校正后的 OD 值为检测波长的测定值减 去参考波长的测定值。

## | 结果分析

1. 推荐拟合曲线坐标对数或自然数，拟合方程常见为直线、二次方程及四参 数方程，通过各种应用软件拟合选取最佳标准曲线，根据样本OD值查找相应浓 度。
2. 稀释的样本计算浓度时应乘以稀释倍数；若样品浓度高于最高线性值，需 稀释样本并重新测定。
3. 示例数据仅供参考， 每次实验 必须制备当次实验的标准曲线。

|   Mouse IL-22 Concentration (pg/mL) |    OD |    OD |   Average OD |
|-------------------------------------|-------|-------|--------------|
|                              200    | 3.436 | 3.455 |        3.446 |
|                              100    | 2.693 | 2.687 |        2.69  |
|                               50    | 1.547 | 1.584 |        1.566 |
|                               25    | 0.957 | 0.839 |        0.898 |
|                               12.5  | 0.407 | 0.449 |        0.428 |
|                                6.25 | 0.236 | 0.247 |        0.242 |
|                               31.3  | 0.146 | 0.128 |        0.137 |
|                                0    | 0.044 | 0.043 |        0.044 |## | 性能数据

- 1． 灵敏度： 1 pg/mL，10 个空白样本的对应浓度平均值加上三倍标准偏差。
- 2． 精密度： 板内精密度：3个已知浓度的样本板内重复测定10次，计算得 到板内变异系数；板间精密度：3个已知浓度的样本板间分别重复测定3次，计 算得到板间变异系数

|            |   板内精密度 |   板内精密度 |   板内精密度 |   板间精密度 |   板间精密度 |   板间精密度 |
|------------|---------|---------|---------|---------|---------|---------|
| 样本         |    1    |    2    |    3    |    1    |    2    |    3    |
| 测试次数       |   10    |   10    |   10    |    9    |    9    |    9    |
| 标准差        |    0.46 |    1.46 |    5.15 |    0.56 |    1.56 |    5.14 |
| 平均值(pg/mL） |    6.74 |   25.8  |  116.36 |    6.74 |   25.63 |  114.81 |
| 变异系数CV（%）  |    6.79 |    5.67 |    4.43 |    8.31 |    6.09 |    4.47 |

- 3． 校准： 试剂盒校准品为达优校准的高纯度重组IL-22。

## | 参考文献

[1] Jia, L., Jiang, Y., Wu, L.et al.Porphyromonas gingivalis aggravates colitis via a gut microbiota-linoleic acid metabolism-Th17/Treg cell balance axis[J].Nat Commun, 2024.

[2] Huang,R.,Jia,B.,Su,D.,Li,M.,Xu,Z.,He,C.,Huang,Y.,Fan,H.,Chen,H., &Cheng,F.(2023).Plant exosomes fused with engineered mesenchymal stemcell-derived nanovesicles for synergistic therapy of autoimmune skin disorders[J].Journal of Extracellular Vesicles.


"""

# 执行产品信息结构化提取
try:
    result = extract_product_info(sample_text)
    print("产品信息提取结果：")
    print(json.dumps(result.model_dump(), ensure_ascii=False, indent=2))
except Exception as e:
    print(f"提取失败：{e}")

# -*- coding: utf-8 -*-
from langchain.agents import create_agent
import json
import os

# 定义产品信息的 JSON Schema（对应基础实现中的ProductInfo结构）
product_info_schema = {
    "type": "object",
    "description": "Product information extracted from documentation.",
    "properties": {
        "name": {"type": "string", "description": "产品名称"},
        "catalog_number": {"type": "string", "description": "规格货号"},
        "description": {"type": "string", "description": "产品描述"},
        "validity_period": {"type": "string", "description": "有效期"},
        "storage_temperature": {"type": "string", "description": "保存温度"}
    },
    "required": []
}

# 设置环境变量
os.environ["OPENAI_API_BASE"] = "https://{HOST}/v1"
os.environ["OPENAI_API_KEY"] = "sk-XXX"

# 创建代理 - 使用 JSON Schema 作为响应格式
agent = create_agent(
    model="openai:XXXX",
    tools=[],  # 可以添加工具，这里暂时为空
    response_format=product_info_schema  # Auto-selects ProviderStrategy
)

def extract_product_info_json(text: str) -> dict:
    """从文本中提取产品结构化信息（使用JSON Schema）"""
    
    try:
        # 使用 langchain agent 进行结构化提取
        result = agent.invoke({
            "messages": [{"role": "user", "content": f"""
请从以下产品说明书中提取结构化信息：

文本内容：
{text}

请提取以下信息：
1. 产品名称
2. 规格货号（产品编号）
3. 产品描述
4. 有效期
5. 保存温度

请严格按照JSON Schema的结构返回结果。
"""}]
        })
        
        # 返回结构化响应
        return result["structured_response"]
            
    except Exception as e:
        print(f"API调用失败: {e}")
        # 返回一个默认的产品信息对象
        return {
            "name": "提取失败",
            "catalog_number": "未知",
            "description": "无法提取产品描述",
            "validity_period": "未知",
            "storage_temperature": "未知"
        }

# 示例文本（使用基础实现中的相同示例）
sample_text = """
## 达优

## Mouse IL-22 Precoated ELISA Kit

Cat#:1212202/1212203

ELISA 试剂盒 说明书

本试剂盒仅供科研使用，请勿用于诊断 使用前请仔细阅读说明书并检查试剂盒组分
## Mouse IL-22

## Precoated ELISA Kit

ELISA试剂盒

## | 检测原理

达优ELISA 试剂盒采用双抗体夹心酶联免疫吸附检测技术。特异性的抗体包 被到酶标板上，标准品或样本加入孔中，样本中含有的目标物质被固定化的抗体 捕获，加入检测抗体，形成抗体-抗原-抗体的复合体，加入酶和底物，在酶的催 化下底物发生反应，且反应的颜色与目标物质的含量成正比，加入终止液后，在 酶标仪中测定反应的吸光值。

## | 预期用途

定量检测血清、血浆、缓冲液或细胞培养液中的IL-22含量。

## | 保存条件

未开封试剂盒在2℃～8℃可稳定保存12个月。
"""

# 执行产品信息结构化提取
try:
    result = extract_product_info_json(sample_text)
    print("产品信息提取结果：")
    print(json.dumps(result, ensure_ascii=False, indent=2))
except Exception as e:
    print(f"提取失败：{e}")

from langchain.agents import create_agent
import json
import os

extended_product_schema = {
    "type": "object",
    "description": "Extended product information with additional details",
    "properties": {
        "name": {"type": "string", "description": "产品名称"},
        "catalog_number": {"type": "string", "description": "规格货号"},
        "description": {"type": "string", "description": "产品描述"},
        "validity_period": {"type": "string", "description": "有效期"},
        "storage_temperature": {"type": "string", "description": "保存温度"},
        "category": {"type": "string", "description": "产品类别"},
        "brand": {"type": "string", "description": "品牌"},
        "precautions": {
            "type": "array",
            "items": {"type": "string"},
            "description": "注意事项列表"
        },
        "specifications": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "spec_name": {"type": "string", "description": "规格名称"},
                    "spec_value": {"type": "string", "description": "规格值"},
                    "unit": {"type": "string", "description": "单位"}
                },
                "required": ["spec_name", "spec_value"]
            },
            "description": "技术规格列表"
        }
    },
    "required": []
}

# 设置环境变量
os.environ["OPENAI_API_BASE"] = "https://{HOST}/v1"
os.environ["OPENAI_API_KEY"] = "sk-XXX"


# 创建扩展产品信息提取代理
extended_agent = create_agent(
    model="openai:XXXX",
    tools=[],
    response_format=extended_product_schema
)

def extract_product_info_json(text: str) -> dict:
    """从产品描述中提取扩展信息"""
    
    try:
        result = extended_agent.invoke({
            "messages": [{"role": "user", "content": f"""
请从以下产品说明书中提取结构化信息：

{text}

请提取以下信息：
1. 产品名称
2. 规格货号（产品编号）
3. 产品描述
4. 有效期
5. 保存温度
6. 产品类别
7. 品牌
8. 注意事项列表
9. 技术规格列表

请严格按照JSON Schema的结构返回结果。
"""}]
        })
        
        return result["structured_response"]
            
    except Exception as e:
        print(f"扩展产品信息提取失败: {e}")
        return {
            "name": "提取失败",
            "catalog_number": "未知",
            "description": "无法提取产品描述",
            "validity_period": "未知",
            "storage_temperature": "未知",
            "category": "未知",
            "brand": "未知",
            "precautions": ["提取过程中出现错误"],
            "specifications": []
        }

# 示例文本（使用基础实现中的相同示例）
sample_text = """
## 达优

## Mouse IL-22 Precoated ELISA Kit

Cat#:1212202/1212203

ELISA 试剂盒 说明书

本试剂盒仅供科研使用，请勿用于诊断 使用前请仔细阅读说明书并检查试剂盒组分
## Mouse IL-22

## Precoated ELISA Kit

ELISA试剂盒

## | 检测原理

达优ELISA 试剂盒采用双抗体夹心酶联免疫吸附检测技术。特异性的抗体包 被到酶标板上，标准品或样本加入孔中，样本中含有的目标物质被固定化的抗体 捕获，加入检测抗体，形成抗体-抗原-抗体的复合体，加入酶和底物，在酶的催 化下底物发生反应，且反应的颜色与目标物质的含量成正比，加入终止液后，在 酶标仪中测定反应的吸光值。

## | 预期用途

定量检测血清、血浆、缓冲液或细胞培养液中的IL-22含量。

## | 保存条件

未开封试剂盒在2℃～8℃可稳定保存12个月。
"""

# 执行产品信息结构化提取
try:
    result = extract_product_info_json(sample_text)
    print("产品信息提取结果：")
    print(json.dumps(result, ensure_ascii=False, indent=2))
except Exception as e:
    print(f"提取失败：{e}")