解：在步骤模式下，可以访问思维/行动。

$x_{1}e^{0}f_{1}x$

请允许我澄清一下。代理运行正常，在Streamlit应用程序中输出结果。但是有层次结构的代理在运行。因此，作为中间步骤，我想在Streamlit UI中显示状态。类似于LangChain如何使用streamlitcallbackhandler实现这一点。

要实现这一点的方法是什么？

To integrate LlamaIndex with Streamlit and display the intermediate steps or status of hierarchical agents in the Streamlit UI, you can use a custom callback handler. This handler will capture the intermediate steps and update the Streamlit UI. Here is an example of how you can achieve this:

1. Create a custom callback handler: This handler will capture the intermediate steps and update the Streamlit UI.
2. Integrate the callback handler with the create_llama_agent function: Pass the custom callback handler to the create_llama_agent function.
3. Update the Streamlit UI: Use Streamlit's st.write or st.text to display the intermediate steps.
   Here is a sample implementation:

import streamlit as st
from llama_index.core.langchain_helpers.agents.agents import create_llama_agent
from llama_index.core.bridge.langchain import BaseLLM, BaseCallbackManager, AgentType
from llama_index.core.langchain_helpers.agents.toolkits import LlamaToolkit

class StreamlitCallbackHandler(BaseCallbackManager):
    def __init__(self):
        self.steps = []

    def on_event(self, event_type, payload):
        if event_type == "function_call":
            self.steps.append(f"Function Call: {payload['function_call']}")
        elif event_type == "function_output":
            self.steps.append(f"Function Output: {payload['function_output']}")
        self.update_ui()

    def update_ui(self):
        st.write("### Intermediate Steps")
        for step in self.steps:
            st.text(step)

# Initialize StreamlitCallbackHandler
callback_handler = StreamlitCallbackHandler()

# Create a LlamaToolkit instance (assuming you have a toolkit instance)
toolkit = LlamaToolkit()

# Initialize the LLM (replace with your LLM instance)
llm = BaseLLM()

# Create the agent with the custom callback manager
agent_executor = create_llama_agent(
    toolkit=toolkit,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    callback_manager=callback_handler
)

# Example task to run
task_input = "Your input here"

# Run the agent executor
output = agent_executor.run(task_input)

# Display the final output
st.write("### Final Output")
st.text(output)

In this example:

• StreamlitCallbackHandler captures the intermediate steps and updates the Streamlit UI.
• create_llama_agent is used to create the agent with the custom callback manager.
• The intermediate steps and final output are displayed in the Streamlit UI.

This approach allows you to visualize the intermediate steps of hierarchical agents in the Streamlit UI, similar to how StreamlitCallbackHandler works with LangChain 1(https://github.com/run-llama/llama_index/blob/main/llama-index-legacy/llama_index/legacy/agent/react/step.py)2(https://github.com/run-llama/llama_index/blob/main/llama-index-core/llama_index/core/langchain_helpers/agents/agents.py).

• To continue talking to Dosu , mention @dosu.*

@dosu Super. And how to implement the same with OpenAI agent with streaming as True

要使用流媒体设置为 True 的 OpenAI 代理实现相同的功能，您可以使用 OpenAIAgentWorker 类中提供的 astream_chat 方法。该方法异步处理流媒体响应。以下是如何调整之前示例的方法：

1. 创建自定义回调处理程序:此处理程序将捕获中间步骤并更新 Streamlit UI。
2. 将回调处理程序与 OpenAIAgentWorker 集成:将自定义回调处理程序传递给 OpenAIAgentWorker 。
3. 更新 Streamlit UI:使用 Streamlit 的 st.write 或 st.text 在 Streamlit UI 中显示中间步骤。
   以下是一个示例实现：

# 在此示例中：

# `StreamlitCallbackHandler` 捕获中间步骤并更新 Streamlit UI。

# `create_llama_agent` 用于使用自定义回调管理器创建代理。

# 使用启用了流媒体的 `OpenAI` LLM 初始化。

# 使用 `astream_chat` 方法异步处理流媒体响应。

# 在 Streamlit UI 中显示中间步骤和最终输出。

# 这种方法允许您在启用了流媒体的 OpenAI 代理 [[1]](https://github.com/run-llama/llama_index/blob/main/llama-index-legacy/llama_index/legacy/agent/legacy/openai_agent.py)[[2]](https://github.com/run-llama/llama_index/blob/main/llama-index-legacy/llama_index/legacy/agent/openai/step.py)[[3]](https://github.com/run-llama/llama_index/blob/main/docs/docs/module_guides/deploying/query_engine/streaming.md) 的 Streamlit UI 中可视化分层代理的中间步骤。

# 要继续与 [Dosu](https://dosu.dev) 交谈，请提及 @dosu。

如果我想将Streamlit Callback Handler类与Streamlit st解耦，如何抽象这个？

要将 StreamlitCallbackHandler 类与 Streamlit 的 st 函数解耦，可以将特定于 Streamlit 的功能抽象到单独的接口或类中。这样，回调处理程序可以在不同的上下文中使用，而不受 Streamlit 的限制。
以下是如何实现这一点的示例：

1. 为输出处理器定义一个接口。
2. 为 Streamlit 实现该接口。
3. 修改 StreamlitCallbackHandler 以使用该接口。
   在这个例子中：

• OutputHandler 是处理输出的接口。
• StreamlitOutputHandler 是使用 Streamlit 的 st.write 函数实现的 OutputHandler。
• StreamingGeneratorCallbackHandler 现在在其构造函数中接受一个 OutputHandler 示例，并使用它写入令牌。

这样，您可以为不同的上下文创建 OutputHandler 的不同实现，使 StreamingGeneratorCallbackHandler 独立于 Streamlit 1(https://github.com/run-llama/llama_index/blob/main/llama-index-legacy/llama_index/legacy/langchain_helpers/streaming.py)2(https://github.com/run-llama/llama_index/blob/main/llama-index-core/llama_index/core/langchain_helpers/streaming.py)。

• 要继续与 Dosu 交谈，请提及 @dosu。