mlflow.langchain

mlflow.langchain.autolog(disable=False, exclusive=False, disable_for_unsupported_versions=False, silent=False, log_traces=True)

注意

已知 Autologging 与以下软件包版本兼容： 0.1.0 <= langchain <= 0.3.27. 在此范围之外的软件包版本中使用 Autologging 可能无法成功。

启用（或禁用）并配置从 Langchain 到 MLflow 的自动日志记录。

Parameters

• disable – 如果 True，则禁用 Langchain autologging 集成。如果 False，则启用 Langchain autologging 集成。

• exclusive – 如果 True，自动记录的内容不会记录到用户创建的 fluent 运行。 如果 False，自动记录的内容会记录到活动的 fluent 运行，该运行可能是用户创建的。

• disable_for_unsupported_versions – 如果 True，则禁用对尚未针对此版本的 MLflow 客户端进行测试或与之不兼容的 langchain 版本的 autologging。

• silent – 如果 True，在 Langchain 自动记录期间抑制来自 MLflow 的所有事件日志和警告。如果 False，在 Langchain 自动记录期间显示所有事件和警告。

• log_traces – 如果 True，则在推理期间通过使用 MlflowLangchainTracer 作为回调为 Langchain 模型记录跟踪信息。如果 False，则在推理期间不收集任何跟踪信息。默认值为 True。

mlflow.langchain.load_model(model_uri, dst_path=None)

注意

已知 ‘langchain’ 的 MLflow Models 集成与 0.0.354 <= langchain <= 0.3.27 兼容。MLflow Models 与 langchain 的集成在使用超出此范围的包版本时可能无法成功。

从本地文件或运行中加载 LangChain 模型。

Parameters

• model_uri –

  MLflow 模型的 URI 格式的位置。例如：

  • /Users/me/path/to/local/model

  • relative/path/to/local/model

  • s3://my_bucket/path/to/model

  • runs:/<mlflow_run_id>/run-relative/path/to/model

  有关受支持的 URI 方案的更多信息，请参见 Referencing Artifacts。

• dst_path – 要将模型工件下载到的本地文件系统路径。该目录必须已存在。如果未指定，将创建一个本地输出路径。

Returns

一个 LangChain 模型实例。

mlflow.langchain.log_model(lc_model, artifact_path: str | None = None, conda_env=None, code_paths=None, registered_model_name=None, signature: mlflow.models.signature.ModelSignature = None, input_example: Union[pandas.core.frame.DataFrame, numpy.ndarray, dict, list, csr_matrix, csc_matrix, str, bytes, tuple] = None, await_registration_for=300, pip_requirements=None, extra_pip_requirements=None, metadata=None, loader_fn=None, persist_dir=None, run_id=None, model_config=None, streamable=None, resources: list[mlflow.models.resources.Resource] | str | None = None, prompts: list[str | Prompt] | None = None, name: str | None = None, params: dict[str, typing.Any] | None = None, tags: dict[str, typing.Any] | None = None, model_type: str | None = None, step: int = 0, model_id: str | None = None)

注意

已知 ‘langchain’ 与 MLflow Models 的集成兼容 0.0.354 <= langchain <= 0.3.27。当在此范围之外的包版本上使用时，MLflow Models 与 langchain 的集成可能无法成功。

将 LangChain 模型记录为当前运行的 MLflow 工件。

Parameters

• lc_model –

  一个 LangChain 模型，可能是 Chain, Agent, 或 retriever ，或是包含上述类型的 LangChain 模型代码 的路径。使用模型作为路径时，请确保通过使用 mlflow.models.set_model() 来设置模型。

  注意

  实验性：将模型作为路径使用可能在未来的版本中发生更改或被移除，恕不另行通知。

• artifact_path – 已弃用。请改用 name。

• conda_env –

  Conda 环境的字典表示或指向 conda 环境 yaml 文件的路径。如果提供，该值描述了应该在其上运行此模型的环境。至少应指定 get_default_conda_env() 所包含的依赖项。如果 None，则会将一个带有由 mlflow.models.infer_pip_requirements() 推断的 pip 依赖项的 conda 环境添加到模型中。如果依赖项推断失败，则回退使用 get_default_pip_requirements。来自 conda_env 的 pip 依赖项会被写入 pip requirements.txt 文件，完整的 conda 环境会写入 conda.yaml。以下是一个 conda 环境字典表示的 示例：

  {
      "name": "mlflow-env",
      "channels": ["conda-forge"],
      "dependencies": [
          "python=3.8.15",
          {
              "pip": [
                  "langchain==x.y.z"
              ],
          },
      ],
  }
  

• code_paths –

  本地文件系统中指向 Python 文件依赖（或包含文件依赖的目录）路径的列表。这些文件在模型加载时会被预先添加到系统路径中。如果为某个模型声明了依赖文件且多个文件之间存在导入依赖关系，那么这些文件应从一个共同的根路径声明相对导入，以避免在加载模型时发生导入错误。

  有关 code_paths 功能、推荐的使用模式和限制的详细说明，请参阅 code_paths usage guide。

• registered_model_name – 如果提供，则在 registered_model_name 下创建一个模型版本，如果不存在具有该名称的注册模型，则同时创建一个注册模型。

• signature –

  ModelSignature 描述模型的输入和输出 Schema。 如果未指定，模型签名将根据 lc_model.input_keys 和 lc_model.output_keys 作为列名设置，并将 DataType.string 作为列类型。 或者，您可以显式指定模型签名。 模型签名可以从具有有效模型输入（例如省略目标列的训练数据集）和有效模型输出（例如在训练数据集上生成的模型预测）的数据集中inferred，例如：

  from mlflow.models import infer_signature
  
  chain = LLMChain(llm=llm, prompt=prompt)
  prediction = chain.run(input_str)
  input_columns = [
      {"type": "string", "name": input_key} for input_key in chain.input_keys
  ]
  signature = infer_signature(input_columns, predictions)
  

• input_example – 一个或多个有效模型输入实例。输入示例用于提示应向模型提供何种数据。它将被转换为一个 Pandas DataFrame，然后使用 Pandas 的 split-oriented 格式序列化为 json，或者转换为一个 numpy array，其中示例将通过将其转换为列表的方式序列化为 json。字节使用 base64 编码。当 signature 参数为 None 时，输入示例用于推断模型签名。

• await_registration_for – 等待模型版本完成创建并进入 READY 状态的秒数。默认情况下，该函数等待五分钟。指定 0 或 None 以跳过等待。

• pip_requirements – 可以是 pip 依赖字符串的可迭代对象（例如 ["langchain", "-r requirements.txt", "-c constraints.txt"]）或本地文件系统上 pip requirements 文件的字符串路径（例如 "requirements.txt"）。如果提供，则描述了应在其运行此模型的环境。如果 None，则由 mlflow.models.infer_pip_requirements() 从当前软件环境推断出默认的依赖列表。如果依赖推断失败，则回退到使用 get_default_pip_requirements。依赖和约束会被自动解析并分别写入 requirements.txt 和 constraints.txt 文件，并作为模型的一部分进行存储。依赖还会写入模型的 conda 环境（conda.yaml）文件的 pip 部分。

• extra_pip_requirements –

  要么是一个 pip 需求字符串的可迭代对象（例如 ["pandas", "-r requirements.txt", "-c constraints.txt"]），要么是本地文件系统上 pip requirements 文件的字符串路径（例如 "requirements.txt"）。如果提供，该参数描述了附加的 pip 依赖，这些依赖会被追加到基于用户当前软件环境自动生成的默认 pip 依赖集合中。requirements 和 constraints 会被自动解析并分别写入 requirements.txt 和 constraints.txt 文件，并作为模型的一部分存储。依赖项也会被写入模型的 conda 环境（conda.yaml）文件的 pip 部分。

  警告

  以下参数不能同时指定：

  • conda_env

  • pip_requirements

  • extra_pip_requirements

  This example 演示了如何使用 pip_requirements 和 extra_pip_requirements 指定 pip 依赖。

• metadata – 传递给模型并存储在 MLmodel 文件中的自定义元数据字典。

• loader_fn –

  一个函数，当模型包含不能被 LangChain 原生序列化的对象时需要。该函数接受一个字符串 persist_dir 作为参数，并返回模型所需的特定对象。根据模型不同，这可能是一个 retriever、vectorstore、requests_wrapper、embeddings 或 database。对于 RetrievalQA Chain 和 retriever 模型，该对象是一个(retriever)。对于 APIChain 模型，它是一个(requests_wrapper)。对于 HypotheticalDocumentEmbedder 模型，它是一个(embeddings)。对于 SQLDatabaseChain 模型，它是一个(database)。

• persist_dir –

  对象存储的目录。The loader_fn 使用这个字符串作为加载对象的参数。 这是针对包含不能被 LangChain 原生序列化的对象的模型的可选项。MLflow 将该目录中的内容作为工件记录在名为 persist_dir_data 的子目录中。

  下面是使用 loader_fn 和 persist_dir 记录 RetrievalQA 链的代码片段：

  注意

  在 langchain_community >= 0.0.27 中，加载 pickled 数据需要提供 allow_dangerous_deserialization 参数。

  qa = RetrievalQA.from_llm(llm=OpenAI(), retriever=db.as_retriever())
  
  
  def load_retriever(persist_directory):
      embeddings = OpenAIEmbeddings()
      vectorstore = FAISS.load_local(
          persist_directory,
          embeddings,
          # 你可能需要添加下面这一行
          # 对于 langchain_community >= 0.0.27
          allow_dangerous_deserialization=True,
      )
      return vectorstore.as_retriever()
  
  
  with mlflow.start_run() as run:
      logged_model = mlflow.langchain.log_model(
          qa,
          name="retrieval_qa",
          loader_fn=load_retriever,
          persist_dir=persist_dir,
      )
  

  完整示例见 examples/langchain/retrieval_qa_chain.py。

• run_id – 要与此模型版本关联的 run_id。如果指定，我们将继续该运行并将模型记录到该运行。否则，将创建一个新的运行。默认值为 None。

• model_config –

  用于在从代码保存模型时应用到模型的模型配置。该配置在加载模型时可用。

  注意

  实验性：该参数可能会在将来的版本中更改或被删除，且不会另行通知。

• streamable – 一个布尔值，表示模型是否支持流式预测。 如果 True，模型必须实现 stream 方法。 如果为 None，如果模型实现了 stream 方法，则将 streamable 设置为 True。 默认值为 None。

• resources – 一份模型资源列表或包含所需资源列表的 resources.yaml 文件，这些资源用于提供模型服务。如果记录一个带有依赖项的 LangChain 模型（例如，依赖于 LLM 模型服务端点），我们建议通过此参数显式传入依赖项。否则，log_model 将尝试推断依赖项，但依赖自动推断是尽力而为的，可能会遗漏某些依赖项。

• prompts –

  一个在 MLflow Prompt Registry 注册的 prompt URI 列表，用于与模型关联。 Each prompt URI should be in the form prompt:/<name>/<version>. 在与模型关联之前，这些 prompt 应该先在 MLflow Prompt Registry 中注册。

  这将在模型和 prompt 之间创建相互链接。关联的 prompt 可以在存储于 MLmodel 文件中的模型元数据中看到。通过 Prompt Registry UI，你也可以导航到该模型。

  import mlflow
  
  prompt_template = "Hi, {name}! How are you doing today?"
  
  # 在 MLflow Prompt Registry 中注册一个 prompt
  mlflow.prompts.register_prompt("my_prompt", prompt_template, description="A simple prompt")
  
  # 使用已注册的 prompt 记录模型
  with mlflow.start_run():
      model_info = mlflow.pyfunc.log_model(
          name=MyModel(),
          name="model",
          prompts=["prompt:/my_prompt/1"]
      )
  
  print(model_info.prompts)
  # 输出：['prompt:/my_prompt/1']
  
  # 加载 prompt
  prompt = mlflow.genai.load_prompt(model_info.prompts[0])
  

• name – 模型名称。

• params – 一个用于与模型一同记录的参数字典。

• tags – 一个要与模型一起记录的标签字典。

• model_type – 模型的类型。

• step – 在该步记录模型输出和指标

• model_id – 模型的 ID。

Returns

一个 ModelInfo 实例，包含已记录模型的元数据。

mlflow.langchain.save_model(lc_model, path, conda_env=None, code_paths=None, mlflow_model=None, signature: mlflow.models.signature.ModelSignature = None, input_example: Union[pandas.core.frame.DataFrame, numpy.ndarray, dict, list, csr_matrix, csc_matrix, str, bytes, tuple] = None, pip_requirements=None, extra_pip_requirements=None, metadata=None, loader_fn=None, persist_dir=None, model_config=None, streamable: bool | None = None)

注意

已知 ‘langchain’ 与 MLflow Models 的集成兼容 0.0.354 <= langchain <= 0.3.27。当在此范围之外的包版本上使用时，MLflow Models 与 langchain 的集成可能无法成功。

将 LangChain 模型保存到本地文件系统的路径。

Parameters

• lc_model –

  一个 LangChain 模型，可能是一个 Chain, Agent, retriever, 或 RunnableSequence, 或者一个路径，包含上述类型的 LangChain model code 。当将 model 用作路径时，确保使用 mlflow.models.set_model() 来设置 model。

  注意

  实验性：将 model 用作路径的用法可能在将来的版本中更改或在没有警告的情况下被移除。

• path – 要保存序列化模型（以 YAML 格式）的本地路径。

• conda_env –

  表示 Conda 环境的字典表示，或指向 conda 环境 yaml 文件的路径。如果提供，该项描述了运行该模型所需的环境。至少，它应当指定 get_default_conda_env() 中包含的依赖项。如果 None，则会向模型添加一个 conda 环境，该环境包含由 mlflow.models.infer_pip_requirements() 推断出的 pip 依赖。如果依赖推断失败，则回退使用 get_default_pip_requirements。来自 conda_env 的 pip 依赖将写入 pip requirements.txt 文件，完整的 conda 环境将写入 conda.yaml。下面是 conda 环境字典表示的一个 示例：

  {
      "name": "mlflow-env",
      "channels": ["conda-forge"],
      "dependencies": [
          "python=3.8.15",
          {
              "pip": [
                  "langchain==x.y.z"
              ],
          },
      ],
  }
  

• code_paths –

  本地文件系统中指向 Python 文件依赖（或包含文件依赖的目录）路径的列表。这些文件在模型加载时会被预先添加到系统路径中。如果为某个模型声明了依赖文件且多个文件之间存在导入依赖关系，那么这些文件应从一个共同的根路径声明相对导入，以避免在加载模型时发生导入错误。

  有关 code_paths 功能、推荐的使用模式和限制的详细说明，请参阅 code_paths usage guide。

• mlflow_model – mlflow.models.Model 此 flavor 正在被添加到。

• signature –

  ModelSignature 描述模型的输入和输出 Schema。 如果未指定，模型签名将根据 lc_model.input_keys 和 lc_model.output_keys 作为列名设置，并将 DataType.string 作为列类型。 或者，您可以显式指定模型签名。 模型签名可以从具有有效模型输入（例如省略目标列的训练数据集）和有效模型输出（例如在训练数据集上生成的模型预测）的数据集中inferred，例如：

  from mlflow.models import infer_signature
  
  chain = LLMChain(llm=llm, prompt=prompt)
  prediction = chain.run(input_str)
  input_columns = [
      {"type": "string", "name": input_key} for input_key in chain.input_keys
  ]
  signature = infer_signature(input_columns, predictions)
  

• input_example – 一个或多个有效模型输入实例。输入示例用于提示应向模型提供何种数据。它将被转换为一个 Pandas DataFrame，然后使用 Pandas 的 split-oriented 格式序列化为 json，或者转换为一个 numpy array，其中示例将通过将其转换为列表的方式序列化为 json。字节使用 base64 编码。当 signature 参数为 None 时，输入示例用于推断模型签名。

• pip_requirements – 要么是一个 pip 要求字符串的可迭代对象（例如 ["langchain", "-r requirements.txt", "-c constraints.txt"]）要么是本地文件系统上 pip requirements 文件的字符串路径（例如 "requirements.txt"）。如果提供，则描述了该模型应在其上运行的环境。如果 None，则默认的 requirements 列表由当前软件环境通过 mlflow.models.infer_pip_requirements() 推断得出。如果需求推断失败，则回退为使用 get_default_pip_requirements。需求和约束会分别自动解析并写入 requirements.txt 和 constraints.txt 文件，并作为模型的一部分存储。需求也会写入模型的 conda 环境（conda.yaml）文件的 pip 部分。

• extra_pip_requirements –

  要么是一个 pip 需求字符串的可迭代对象（例如 ["pandas", "-r requirements.txt", "-c constraints.txt"]），要么是本地文件系统上 pip requirements 文件的字符串路径（例如 "requirements.txt"）。如果提供，该参数描述了附加的 pip 依赖，这些依赖会被追加到基于用户当前软件环境自动生成的默认 pip 依赖集合中。requirements 和 constraints 会被自动解析并分别写入 requirements.txt 和 constraints.txt 文件，并作为模型的一部分存储。依赖项也会被写入模型的 conda 环境（conda.yaml）文件的 pip 部分。

  警告

  以下参数不能同时指定：

  • conda_env

  • pip_requirements

  • extra_pip_requirements

  This example 演示了如何使用 pip_requirements 和 extra_pip_requirements 指定 pip 依赖。

• metadata – 传递给模型并存储在 MLmodel 文件中的自定义元数据字典。

• loader_fn –

  一个针对包含非由 LangChain 原生序列化对象的模型所必需的函数。 该函数以一个字符串 persist_dir 作为参数并返回模型所需的特定对象。根据模型不同， 这可能是一个 retriever、vectorstore、requests_wrapper、embeddings 或 database。对于 RetrievalQA Chain 和 retriever 模型，该对象是一个 (retriever)。 对于 APIChain 模型，它是一个 (requests_wrapper)。 对于 HypotheticalDocumentEmbedder 模型，它是一个 (embeddings)。 对于 SQLDatabaseChain 模型，它是一个 (database).

• persist_dir –

  存储对象的目录。loader_fn 将此字符串作为参数来加载对象。对于包含未由 LangChain 原生序列化的对象的模型，此项为可选。MLflow 将此目录中的内容作为名为 persist_dir_data 的子目录中的工件进行日志记录。

  下面是在使用 loader_fn 和 persist_dir 记录 RetrievalQA 链时的代码片段：

  注意

  在 langchain_community >= 0.0.27 中，加载 pickled 数据需要提供 allow_dangerous_deserialization 参数。

  qa = RetrievalQA.from_llm(llm=OpenAI(), retriever=db.as_retriever())
  
  
  def load_retriever(persist_directory):
      embeddings = OpenAIEmbeddings()
      vectorstore = FAISS.load_local(
          persist_directory,
          embeddings,
          # 你可能需要添加下面这一行
          # 针对 langchain_community >= 0.0.27
          allow_dangerous_deserialization=True,
      )
      return vectorstore.as_retriever()
  
  
  with mlflow.start_run() as run:
      logged_model = mlflow.langchain.log_model(
          qa,
          name="retrieval_qa",
          loader_fn=load_retriever,
          persist_dir=persist_dir,
      )
  

  完整示例见 examples/langchain/retrieval_qa_chain.py。

• model_config –

  如果从代码保存模型，需要应用到模型的配置。此配置在模型加载时可用。

  注意

  实验性：此参数在未来版本中可能在未通知的情况下更改或被移除。

• streamable – 一个布尔值，表示模型是否支持流式预测。如果 True，模型必须实现 stream 方法。如果为 None，则如果模型实现了 stream 方法，streamable 将被设置为 True。默认值为 None。

class mlflow.langchain.chat_agent_langgraph.ChatAgentState

注意

实验性：此类可能在未来的发布中被更改或移除，且不另行通知。

辅助类，用于构建一个 LangGraph 智能体，该智能体在状态更新时生成与 ChatAgent 兼容的消息。其他 ChatAgent 请求字段（custom_inputs、context）和响应字段（custom_outputs）也在状态中公开，因此可以在智能体执行过程中使用并更新。将此类与 ChatAgentToolNode 一起使用。

LangGraph 聊天智能体 示例

此示例已在 LangGraph 0.2.70 上测试可用。

第1步：创建 LangGraph 智能体

此示例改编自 LangGraph 的 create_react_agent 文档。显著的差异是为了与 ChatAgent 兼容所做的更改。主要包括：

• 我们使用 ChatAgentState，其内部状态为 ChatAgentMessage 对象，并在底层具有 custom_outputs 属性

• 我们使用 ChatAgentToolNode 而不是 LangGraph’s ToolNode，以便能够从 LangChain 和 UnityCatalog 工具返回 attachments 和 custom_outputs

from typing import Optional, Sequence, Union

from langchain_core.language_models import LanguageModelLike
from langchain_core.runnables import RunnableConfig, RunnableLambda
from langchain_core.tools import BaseTool
from langgraph.graph import END, StateGraph
from langgraph.graph.state import CompiledStateGraph
from langgraph.prebuilt import ToolNode
from mlflow.langchain.chat_agent_langgraph import ChatAgentState, ChatAgentToolNode


def create_tool_calling_agent(
    model: LanguageModelLike,
    tools: Union[ToolNode, Sequence[BaseTool]],
    agent_prompt: Optional[str] = None,
) -> CompiledStateGraph:
    model = model.bind_tools(tools)

    def routing_logic(state: ChatAgentState):
        last_message = state["messages"][-1]
        if last_message.get("tool_calls"):
            return "continue"
        else:
            return "end"

    if agent_prompt:
        system_message = {"role": "system", "content": agent_prompt}
        preprocessor = RunnableLambda(
            lambda state: [system_message] + state["messages"]
        )
    else:
        preprocessor = RunnableLambda(lambda state: state["messages"])
    model_runnable = preprocessor | model

    def call_model(
        state: ChatAgentState,
        config: RunnableConfig,
    ):
        response = model_runnable.invoke(state, config)

        return {"messages": [response]}

    workflow = StateGraph(ChatAgentState)

    workflow.add_node("agent", RunnableLambda(call_model))
    workflow.add_node("tools", ChatAgentToolNode(tools))

    workflow.set_entry_point("agent")
    workflow.add_conditional_edges(
        "agent",
        routing_logic,
        {
            "continue": "tools",
            "end": END,
        },
    )
    workflow.add_edge("tools", "agent")

    return workflow.compile()

第2步：定义 LLM 和你的工具

如果你想从你的工具返回 attachments 和 custom_outputs，你可以返回一个包含键 “content”、“attachments” 和 “custom_outputs” 的字典。该字典将由 ChatAgentToolNode 解析并正确存储到你的 LangGraph 的状态中。

from random import randint
from typing import Any

from databricks_langchain import ChatDatabricks
from langchain_core.tools import tool


@tool
def generate_random_ints(min: int, max: int, size: int) -> dict[str, Any]:
    """Generate size random ints in the range [min, max]."""
    attachments = {"min": min, "max": max}
    custom_outputs = [randint(min, max) for _ in range(size)]
    content = f"Successfully generated array of {size} random ints in [{min}, {max}]."
    return {
        "content": content,
        "attachments": attachments,
        "custom_outputs": {"random_nums": custom_outputs},
    }


mlflow.langchain.autolog()
tools = [generate_random_ints]
llm = ChatDatabricks(endpoint="databricks-meta-llama-3-3-70b-instruct")
langgraph_agent = create_tool_calling_agent(llm, tools)

第3步：用 ChatAgent 包装你的 LangGraph 智能体

这使得你的智能体在 serving 中能够更容易地以 PyFunc flavor 进行日志记录和部署。

from typing import Any, Generator, Optional

from langgraph.graph.state import CompiledStateGraph
from mlflow.pyfunc import ChatAgent
from mlflow.types.agent import (
    ChatAgentChunk,
    ChatAgentMessage,
    ChatAgentResponse,
    ChatContext,
)


class LangGraphChatAgent(ChatAgent):
    def __init__(self, agent: CompiledStateGraph):
        self.agent = agent

    def predict(
        self,
        messages: list[ChatAgentMessage],
        context: Optional[ChatContext] = None,
        custom_inputs: Optional[dict[str, Any]] = None,
    ) -> ChatAgentResponse:
        request = {"messages": self._convert_messages_to_dict(messages)}

        messages = []
        for event in self.agent.stream(request, stream_mode="updates"):
            for node_data in event.values():
                messages.extend(
                    ChatAgentMessage(**msg) for msg in node_data.get("messages", [])
                )
        return ChatAgentResponse(messages=messages)

    def predict_stream(
        self,
        messages: list[ChatAgentMessage],
        context: Optional[ChatContext] = None,
        custom_inputs: Optional[dict[str, Any]] = None,
    ) -> Generator[ChatAgentChunk, None, None]:
        request = {"messages": self._convert_messages_to_dict(messages)}
        for event in self.agent.stream(request, stream_mode="updates"):
            for node_data in event.values():
                yield from (
                    ChatAgentChunk(**{"delta": msg}) for msg in node_data["messages"]
                )


chat_agent = LangGraphChatAgent(langgraph_agent)

第4步：测试你的模型

调用 .predict() 和 .predict_stream，传入符合 ChatAgentRequest 模式的字典。

chat_agent.predict({"messages": [{"role": "user", "content": "What is 10 + 10?"}]})

for event in chat_agent.predict_stream(
    {"messages": [{"role": "user", "content": "Generate me a few random nums"}]}
):
    print(event)

这个 LangGraph ChatAgent 可以使用在 ChatAgent 的文档字符串中“Logging a ChatAgent”一节所述的记录代码进行记录。

class mlflow.langchain.chat_agent_langgraph.ChatAgentToolNode(*args: Any, **kwargs: Any)

注意

实验性：此类在将来的版本中可能会更改或被移除，恕不另行通知。

辅助类，用于使 ToolNodes 与 ChatAgentState 兼容。 从 LangGraph 工具的字符串输出中解析 attachments 和 custom_outputs 键。

class mlflow.langchain.output_parsers.ChatAgentOutputParser(*args: Any, **kwargs: Any)

注意

实验性：此类可能在将来的版本中更改或在未发出警告的情况下被移除。

OutputParser 将字符串输出封装为ChatAgentResponse或ChatAgentChunk的字典表示，以便于互操作。