Agent理解以及基于大模型LLM的智能体Agent框架LlamIndex和LangChain介绍

BGoodHabit

已于 2024-07-31 14:33:10 修改

阅读量131

点赞数 2

分类专栏： ChatGPT NLP 文章标签： langchain LlamIndex Agent LLM

于 2024-07-31 12:13:06 首次发布

本文链接：https://blog.csdn.net/BGoodHabit/article/details/139927135

版权

NLP 同时被 2 个专栏收录

29 篇文章 19 订阅

订阅专栏

ChatGPT

7 篇文章 0 订阅

订阅专栏

1 Agent介绍

LLM Powered Autonomous Agents
基于大模型的agent系统，LLM在整个agent系统里面起到大脑的作用。agent系统核心框架图如下：在这里插入图片描述
接下来，我们来分别介绍一下这几个核心成分。

1.2 Planning

问题分解(Task Decompositon)：Agent将一个复杂的大目标拆分成小的，可执行的子目标。解决一个复杂的任务通常由多个简单的子任务完成，对问题的分解，通常有如下几种常见的方法：

Chain of Thought (CoT) 已经成为了一个常见的提高模型在复杂任务表现的一个prompt技术框架。通过"think step by step"来指引模型的思考过程，将复杂任务分解成多个简单的任务进行执行，从而提升模型的表现。
Tree of Thoughts是对CoT方法的扩展，通过探索对每一个step的多个推理可能。首先将问题分解成多个steps然后对每个step产生多个thoughts，会形成生一个树的结构。搜索过程可以通过BFS(广度优先搜索）或者DFS(深度优先搜索），每个状态的评估可以通过一个构建prompt分类器或者多数投票机制。
任务分解可以通过构建1）通过prompt让大模型进行任务分解，比如我们可以这么设计prompt：完成T任务的步骤是什么；又或者实现T任务的子目标是什么等。2）通过具体任务的指令，比如针对写一篇小说任务，我们可以这么设计prompt: 书写一个小说的提纲。3）人为的构建任务分解

自我反思和更正(Self-Reflection)：自我反省让agent可以纠正过去的动作带来的错误。这在实际场景中扮演了重要的角色，因为犯错是不看避免的。根据历史的actions和反馈结果，Agent可以从错误中进行学习，并且进行自我更正，提高最终的效果。

ReAct将推理和行动与LLM融合，让大模型可以与环境交换（比如使用一些工具产出的结果等），通过从环境获取的新的信息进行推理。ReAct prompt模板构成如下：
Thought:…
Action:…
Observation:…
… (Repeated many times)
在知识密集型以及决策性任务中，ReAct效果要比只有Act (去除了Thought)的效果要好。
Reflexion是一个框架旨在为Agent提供动态记忆和自我反思的能力，以提高推理能力。Reflexion 采用标准的强化学习（RL）设置，其中奖励模型提供简单的二元奖励，操作空间遵循 ReAct 的设置，通过增加语言来支持复杂的推理步骤。每个动作之后，代理都会计算一个启发式方法，并可能根据自我反思的结果决定是否重置环境以开始新的尝试。整体框架图如下：

启发函数(heuristic function) 用于确定轨迹何时无效或包含幻觉并应停止。无效的计划是指在没有成功的情况下花费太多时间的轨迹。幻觉被定义为遇到一系列连续相同的操作，这些操作在环境中导致相同的观察结果。
自我反思是通过向大语言模型（LLM）展示两次示例来创建的，每个示例都是一对（失败的轨迹、指导未来计划变化的理想反思）。然后，将这些反思添加到代理的工作记忆中，最多可以添加三个，以用作查询LLM的上下文。
Chain of Hindsight 该方法鼓励模型通过显式呈现过去输出序列（每个都带有反馈注释）来改进其自身的输出。人类反馈数据是一个集合， $D_h={(x,y_i,r_i,z_i)}_{i=1}^n$ 其中x是prompt， $y_i$ 是模型生成的内容， $r_i$ 是人类对 $y_i$ 的评分， $z_i$ 是人类提供的反馈。模型微调后只能在序列前缀的条件下预测 $y_i$ ，以便模型可以根据反馈序列进行自我反思，从而产生更好的输出。模型在测试时可以选择多轮与人类注释者的指令互动。具体细节可以参考原始论文的讲解。

1.3 Memory

记忆可以定义为获取、存储、保持和随后检索信息的过程。人脑中有几种不同类型的记忆，如下：

感觉记忆: 这是记忆的最早阶段，提供在原始刺激结束后保留感觉信息（视觉、听觉等）印象的能力。感觉记忆通常只能持续几秒钟。感觉记忆的子类别包括图像记忆（视觉）、回声记忆（听觉）和触觉记忆（触觉）。
短期记忆: 据信短期记忆的容量约为7个项目（Miller, 1956），持续时间为20到30秒，我们可以理解所有基于context的学习都是利用模型的短期记忆来进行学习，它存储我们当前意识到的信息，并用于执行复杂的认知任务，如学习和推理。
长期记忆: 长期记忆能够存储信息的时间非常长，从几天到几十年不等，并且存储容量基本上是无限的。长期记忆可以给agent提供了较长时间保留和提供信息的能力，通常利用外部向量存储和检索的能力。

1.4 工具的使用

工具的使用是人类一个显著而独特的特征。我们创造、修改和使用外部物体来完成超出我们身体和认知限制的任务。同样，为大语言模型（LLMs）配备外部工具可以显著扩展模型的能力。Agent系统可以调用外部的API接口，获得更多的外部资源和信息，加强系统处理问题的能力。如下是一些目前常见的一些工具集合：

MRKL 是“Modular Reasoning, Knowledge and Language”的简称。这是一个用于自主代理的神经-符号架构。MRKL 系统被提议包含一组“专家”模块，而通用的大语言模型（LLM）则作为路由器，将查询路由到最合适的专家模块。这些模块可以是神经的（例如，深度学习模型）或符号的（例如，数学计算器、货币转换器、天气 API）

TALM (Tool Augmented Language Models) 和 Toolformer 对大语言模型（LM）进行微调，使其学会使用外部工具 API。数据集会根据新添加的 API 调用注释是否能提高模型输出的质量进行扩展。其中ChatGPT插件以及OpenAI的API功能函数功能都是非常好的例子，利用工具加强LLM的能力。

1.5 Agent执行流程

通过对上面agent的基本信息的介绍，Agent系统的基本执行流程和步骤如下：

Task planing: 大模型作为大脑，用来解析用户的请求，将复杂任务分解成多个简单的任务，然后依次执行每个任务。
Tool selection: 针对当前的子任务，大模型决策使用什么工具解决，并且生成调用工具需要的参数
Tool execution: agent框架执行大模型选择的工具，并获得工具产出的结果
Response generation: 将工具返回的结果融合之前的整个上下文信息给到大模型，大模型会进一步判断当前信息是否解决用户的问题，若解决则生成答案给到用户，若是还不能解决，则重复上述步骤。

1.6 Case Studies

我们可以通过详细补充我们的system prompt，让大模型可以更好的理解任务要求，以及有哪些工具可以供使用，包括工具的作用等，这对于LLM理解任务是十分重要的，比如在AutoGPT 里面，如下就是system message的模板：

You are {{ai-name}}, {{user-provided AI bot description}}.
Your decisions must always be made independently without seeking user assistance. Play to your strengths as an LLM and pursue simple strategies with no legal complications.

GOALS:

1. {{user-provided goal 1}}
2. {{user-provided goal 2}}
3. ...
4. ...
5. ...

Constraints:
1. ~4000 word limit for short term memory. Your short term memory is short, so immediately save important information to files.
2. If you are unsure how you previously did something or want to recall past events, thinking about similar events will help you remember.
3. No user assistance
4. Exclusively use the commands listed in double quotes e.g. "command name"
5. Use subprocesses for commands that will not terminate within a few minutes

Commands:
1. Google Search: "google", args: "input": "<search>"
2. Browse Website: "browse_website", args: "url": "<url>", "question": "<what_you_want_to_find_on_website>"
3. Start GPT Agent: "start_agent", args: "name": "<name>", "task": "<short_task_desc>", "prompt": "<prompt>"
4. Message GPT Agent: "message_agent", args: "key": "<key>", "message": "<message>"
5. List GPT Agents: "list_agents", args:
6. Delete GPT Agent: "delete_agent", args: "key": "<key>"
7. Clone Repository: "clone_repository", args: "repository_url": "<url>", "clone_path": "<directory>"
8. Write to file: "write_to_file", args: "file": "<file>", "text": "<text>"
9. Read file: "read_file", args: "file": "<file>"
10. Append to file: "append_to_file", args: "file": "<file>", "text": "<text>"
11. Delete file: "delete_file", args: "file": "<file>"
12. Search Files: "search_files", args: "directory": "<directory>"
13. Analyze Code: "analyze_code", args: "code": "<full_code_string>"
14. Get Improved Code: "improve_code", args: "suggestions": "<list_of_suggestions>", "code": "<full_code_string>"
15. Write Tests: "write_tests", args: "code": "<full_code_string>", "focus": "<list_of_focus_areas>"
16. Execute Python File: "execute_python_file", args: "file": "<file>"
17. Generate Image: "generate_image", args: "prompt": "<prompt>"
18. Send Tweet: "send_tweet", args: "text": "<text>"
19. Do Nothing: "do_nothing", args:
20. Task Complete (Shutdown): "task_complete", args: "reason": "<reason>"

Resources:
1. Internet access for searches and information gathering.
2. Long Term memory management.
3. GPT-3.5 powered Agents for delegation of simple tasks.
4. File output.

Performance Evaluation:
1. Continuously review and analyze your actions to ensure you are performing to the best of your abilities.
2. Constructively self-criticize your big-picture behavior constantly.
3. Reflect on past decisions and strategies to refine your approach.
4. Every command has a cost, so be smart and efficient. Aim to complete tasks in the least number of steps.

You should only respond in JSON format as described below
Response Format:
{
    "thoughts": {
        "text": "thought",
        "reasoning": "reasoning",
        "plan": "- short bulleted\n- list that conveys\n- long-term plan",
        "criticism": "constructive self-criticism",
        "speak": "thoughts summary to say to user"
    },
    "command": {
        "name": "command name",
        "args": {
            "arg name": "value"
        }
    }
}
Ensure the response can be parsed by Python json.loads

从上面prompt例子可以我们可以看出在system模板中详细介绍了工具的作用，工具输入参数格式要求以及对模型输出的一些限制等。这样可以更好的指导大模型如何理解和处理任务，并且按照要求的格式输出。

2 现有Agent框架

2.1 LlamIndex

2.1.1 背景介绍

LlamaIndex 是一个用来构建基于LLM上下文增强生成式的AI应用框架。LlamaIndex提供了从原型到生产环境构建上下文增强的工具。提供了基础工具允许你摄取、解析、索引和处理你的数据，并快速实现结合数据访问与LLM提示的复杂查询工作流。目前基于上下文增强的Retrieval-Augmented Generation (RAG)，在推理的时候LLM结合上下文信息进行推理，提高答案的精准性。LlamIndex框架提供了一些比较实用的工具接口：

数据链接器(Data connectors)：可以将最原始的数据和格式进行链接，比如APIs以及PDFs，SQL等数据格式
数据索引(Data indexes)：可以将你的数据进行结构化表征，更容易被大模型实用
引擎(Engines)：提供了处理你数据的自然语言引擎，比如Query engines对于问答比如RAG是一个很强的接口。Chat engines 是针对多上下文信息处理的对话接口，可以很方便的与你的数据进行交互。
智能处理体(Agents): 是一个富有知识的处理者，利用工具加强了大模型LLM的能力。
可观察/评估集成（Observability/Evaluation ): 能够在良性循环中严格地实验、评估和监控你的应用程序.
官网给出了比较详细的文档，给出了如何调用LLM集成做各种任务的Agents，如下所示：

可以看出有比较详细的例子，想深入理解，我们可以进入官网的一些说明进行详细解读。

2.1.2 构建agent

我们以LLamIndex框架，如何构建agent。首先我们需要安装LlamIndex python包，一行命令就可以按照，如下所示：

pip install llama-index

在这里我们先介绍一下什么是ReAct agent。

ReAct是一种能够让LLM进行推理并且采取具体行动的技术。ReAct包括了思想链以及行动计划。ReAct让LLM创建推理链路以及采取的具体的行动，通过使用记忆，这加强了它们之间的协同作用。
ReACT agent指的是一个框架，它将大型语言模型（LLM）的推理能力与采取实际行动的能力相结合，创建了一个更复杂的系统。该系统可以理解和处理信息，评估情况，采取适当的行动，沟通回应，并跟踪正在进行的情况。具体的框架图如下：

接下来，我们基于Mistral大模型，如何写一个基本的能够调用数值计算工具解决用户问题的agent，在调用大模型之前，先确保有一个Mistral API的key。首先我们先完成工具的实现：

def multiply(a:int, b:int) -> int:
    """Multiple two integers and returns the result integer"""
    return a * b

def add(a:int, b:int) -> int:
    """Add two integers and returns the result integer"""
    return a + b

# tools
multiply_tool = FunctionTool.from_defaults(fn=multiply)
add_tool = FunctionTool.from_defaults(fn=add)
tools = [multiply_tool,add_tool]

然后我们就可以基于Llamindex框架实现一个基本的agent，基本代码如下：

from llama_index.llms.mistralai import MistralAI
from llama_index.core.tools import FunctionTool,QueryEngineTool, ToolMetadata
from llama_index.core import PromptTemplate,SimpleDirectoryReader, VectorStoreIndex
from prompts.system_prompt import customize_prompt
from llama_index.embeddings.mistralai import MistralAIEmbedding
import os
from llama_index.core.agent import FunctionCallingAgentWorker,AgentRunner, ReActAgentWorker, ReActAgent

# llm
llm = MistralAI(model="mistral-large-latest", api_key=mistralai_api_key)

def caculate_agent():
    agent_worker = FunctionCallingAgentWorker.from_tools(
        [multiply_tool, add_tool],
        llm = llm,
        verbose=True,
        allow_parallel_tool_calls=False,
    )
    agent = AgentRunner(agent_worker)
    question = "What is (121 * 3) + 42?"
    response = agent.chat(question)
    print(str(response))

从上面代码可以看出，基于Llamindex框架实现一个简单的agent是十分方便的，主要步骤如下：

定义你的工具tool，在定义工具的时候，需要在函数说明里写清楚这个工具是做什么的，以方便大模型对工具时的理解。
选择基础的LLM，Llamindex支持绝大部分大模型，每个模型的调用前需要去官网注册，生成自己的api_key
构建agent，基于FunctionCallingAgentWorker将工具以及LLM输入，生成agent_work，然后基于AgentRunner生成整体的agent，最后，通过agent.chat进行输入和输出信息的生成。

接下来我们基于ReAct框架，对模型在每一步的思考和动作的采取上面进行跟踪，方便我们更好的理解大模型是怎么对问题进行分解和回答：

def react_agent():
    agent = ReActAgent.from_tools(tools, llm=llm, verbose=True)
    # react_step_engine = ReActAgentWorker.from_tools(tools, llm=llm, verbose=True)
    # agent = AgentRunner(react_step_engine)
    # show system prompt
    prompt_dict = agent.get_prompts()
    for k,v in prompt_dict.items():
        print(f"Prompt: {k}\n\nValue: {v.template}")
    question = "What is (121 * 3) + 42?"
    print("**********原始system prompt的结果*******************")
    agent.chat(question)

    # customizing the system prompt
    react_system_prompt = customize_prompt()
    agent.update_prompts({"agent_worker:system_prompt": react_system_prompt})
    agent.reset()
    agent.get_prompts()
    prompt_dict = agent.get_prompts()
    for k,v in prompt_dict.items():
        print(f"Prompt: {k}\n\nValue: {v.template}")
    question = "What is (121 * 3) + 42?"
    print("**********如下是修改system prompt后的结果*******************")
    agent.chat(question)

在上面的代码里我们对system prompt进行了简单的修改，其中customize_prompt是将原来的system prompt里面再额外增加了一点要求说明，如下所示：
在这里插入图片描述
前后大模型在回答问题的对比如下：

我们可以看出，对system prompt进行调整后，大模型能够针对我们的要求对输出的方式进行对应调整。接下来，我们实现一个RAG (Retrieval-Augmented Generation) 功能。
首先，我们从网上下载一份数据：

mkdir -p 'data/10k/'
wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' -O 'data/10k/uber_2021.pdf'

然后基于这份数据，我们可以基于向量检索，然后得到核心的内容信息片段，再交给LLM进行理解，生成最终的答案。具体代码我们可以这样实现：

def rag_agent():
    # 获取当前执行文件的绝对路径
    file_path = os.path.abspath(__file__)
    directory = os.path.dirname(file_path)
    source_path = directory+'/data/10k/uber_2021.pdf'
    embed_model = MistralAIEmbedding(api_key=mistralai_api_key)
    query_llm = MistralAI(model="mistral-medium",api_key=mistralai_api_key)
    # load data
    uber_docs = SimpleDirectoryReader(
        input_files=[source_path]
    ).load_data()
    # build index
    uber_index = VectorStoreIndex.from_documents(
        uber_docs, embed_model=embed_model
    )
    uber_engine = uber_index.as_query_engine(similary_top_k=3,llm=query_llm)
    query_engine_tool = QueryEngineTool(
        query_engine=uber_engine,
        metadata=ToolMetadata(
            name="uber_10k",
            description=(
                "Provides information about Uber financials for year 2021."
                "Use a detailed plain text question as input to the tool"
            ),
        ),
    )
    agent_worker = FunctionCallingAgentWorker.from_tools(
    [query_engine_tool], llm=llm, verbose=True
    )
    agent = agent_worker.as_agent()
    response = agent.chat("Tell me both the risk factors and tailwinds for Uber? Do two parallel tool calls")
    print(str(response))

模型输出的结果如下：
在这里插入图片描述
从上面可以看出，通过调用向量检索工具，从文本中抽取了与用户问题最相似的上下文信息，然后将这些上下文信息输入给模型进行解答，模型就可以对其进行理解和回答了。

详情代码可以在git上的进行查看。

2.2 LangChain

2.2.1 背景介绍

LangChain 是一个基于LLM开发应用程序的框架。LangChain简化了LLM应用程序生命周期的每个阶段。整个框架的结构图如下：
在这里插入图片描述
目前整个框架主要有如下几个开源的资源库组成：

langchain-core：LangChain表达式语言
langchain-community：第三方库的集成，比如angchain-openai, langchain-anthropic, 等。
langchain：包含了一些Chains, agents, and retrieval strategies等。
LangGraph: 通过图的节点和边进行构建机器人和有状态的多功能体的应用程序。
LangServe: 将 LangChain 链部署为 REST API
LangSmith: 一个开发平台可以让你debug，测试以及监控和评估LLM的应用程序。

2.2.2 Agent构建

LLM不能自己执行动作，他们只是产出输出内容，所以LangChain的一个最大的好处是创建智能体，Agent系统将LLM作为一个推理引擎，用LLM能力配合外部信息 (工具，功能函数等）使用，更智能的构建基于LLM的应用程序。在这里我们简单介绍几个用LangChain构建基础的基于LLM的应用程序。

实现翻译的功能
如下是基于LangChain实现一个基本的翻译应用：

#!/usr/bin/env python
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_mistralai import ChatMistralAI
from dotenv import load_dotenv
load_dotenv(override=True)

def chain_example():

    # 1. Create prompt template
    system_template = "Translate the following into {language}:"
    prompt_template = ChatPromptTemplate.from_messages(
        [("system",system_template),("user","{text}")]
    )

    # 2. Create model
    model = ChatMistralAI()

    # 3. Create parser
    parser = StrOutputParser()

    # 4. create chain
    chain = prompt_template | model | parser

    result = chain.invoke({"language":"bengali","text":"I love you"})
    print(result)


if __name__=='__main__':
    chain_example()

可以看出整体代码是比较简单的，我们可以看出模型的输出结果如下：
在这里插入图片描述

实现情感分析

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_mistralai import ChatMistralAI

from dotenv import load_dotenv
load_dotenv(override=True)

tagging_prompt = ChatPromptTemplate.from_template(
    """
Extract the desired information from the following passage.

Only extract the properties mentioned in the 'Classification' function.

Passage:
{input}
"""
)

class Classification(BaseModel):
    sentiment: str = Field(..., enum=["happy", "neutral", "sad"])
    aggressiveness: int = Field(
        ...,
        description="describes how aggressive the statement is, the higher the number the more aggressive",
        enum=[1, 2, 3, 4, 5],
    )
    language: str = Field(
        ..., enum=["spanish", "english", "french", "german", "italian"]
    )


def classification():
    llm = ChatMistralAI(model="mistral-large-latest", temperature=0) \
        .with_structured_output(Classification)

    chain = tagging_prompt | llm
    inp = "Weather is ok here, I can go outside without much more than a coat"
    result = chain.invoke({"input": inp})
    print(result)


if __name__=='__main__':
    classification()

运行结果如下：
在这里插入图片描述

实现信息结构化抽取

#!/usr/bin/env python
from typing import Optional,List
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_mistralai import ChatMistralAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from dotenv import load_dotenv
load_dotenv(override=True)

system_prompt = (
    "You are an expert extraction algorithm. "
    "Only extract relevant information from the text. "
    "If you do not know the value of an attribute asked to extract, "
    "return null for the attribute's value."
)

prompt = ChatPromptTemplate.from_messages(
    [
        ("system", system_prompt),
        ("human", "{text}"),
    ]
)

class Person(BaseModel):
    """ Information about a person """
    name: Optional[str] = Field(default=None, description="The name")
    hair_color: Optional[str] = Field(
        default=None, description="The color of the person's hair if known")
    height_in_meters: Optional[str] = Field(
        default=None, description="Height measured in meters"
    )

class Data(BaseModel):
    """Extracted data about people."""
    people: List[Person]


def extract():
    # set temperature=0 for high probability output
    llm = ChatMistralAI(model="mistral-large-latest", temperature=0)
    runnable = prompt | llm.with_structured_output(schema=Data)
    text = "My name is Jeff, my hair is black and i am 6 feet tall. Anna has the same color hair as me."
    result = runnable.invoke({"text": text})
    print(result)


if __name__=='__main__':
    extract()

结果如下：
在这里插入图片描述
从上面的三个例子可以看出，基于LangChain做各种应用是是否方便的，而且LangChain中提供了很多实用的工具，结合工具外部资源信息的实用，可以充分发挥LLM能力，更智能的构建agent。我们需要实现什么的功能，可以基于官网给的例子，结合自己的应用，开发对应的Agent是十分高效的。

2.2.3 如何Debug

当我们在设计LLM应用的时候，如果出来的结果不符合预期或者想了解LLM如何对复杂任务进行执行的，想清楚具体的每个步骤，那么就需要进行debug，在LangChain中提供了三种debug方法，具体如下：

Verbose Mode：增加了打印出chain中重要event的状态结果
Debug Mode：对所有事件都增加了日志的状态
LangSmith Tracing：对所有事件的日志结果进行可视化输出

它们对比形式如下：
在这里插入图片描述
首先我们先在Tavily AI网站上获取一个api key。Tavily Search API 是一个搜索引擎，重点是对基于LLM和RAG任务搜索的一个优化，目标是高效，快速。能够从线上资源搜索，过滤，抽取等相关的信息。详细信息可以Tavily的官网文档。同时需要提前在LangSmith注册一个api key。三种debug方式试用代码如下：

#!/usr/bin/env python
from langchain_core.prompts import ChatPromptTemplate
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.output_parsers import StrOutputParser
from langchain_mistralai import ChatMistralAI
from langchain.globals import set_verbose,set_debug
from langsmith import traceable,Client
from dotenv import load_dotenv
load_dotenv(override=True)


# define llm
llm = ChatMistralAI(model="mistral-large-latest", temperature=0)

# define tools
tools = [TavilySearchResults(max_results=1)]

# define prompt
prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "You are a helpful assistant.",
        ),
        ("placeholder", "{chat_history}"),
        ("human", "{input}"),
        ("placeholder", "{agent_scratchpad}"),
    ]
)

# define agent
agent = create_tool_calling_agent(llm, tools, prompt)

def verbose():
    set_verbose(True)
    agent_executor = AgentExecutor(agent=agent, tools=tools)
    agent_executor.invoke(
        {"input": "Who directed the 2023 film Oppenheimer and what is their age in days?"}
    )

def debug():
    set_debug(True)
    set_verbose(False)
    agent_executor = AgentExecutor(agent=agent, tools=tools)
    agent_executor.invoke(
        {"input": "Who directed the 2023 film Oppenheimer and what is their age in days?"}
    )

def add_dataset():
    client = Client()
    dataset_name = "QA Example Dataset Lily"
    dataset = client.create_dataset(dataset_name)
    client.create_examples(
        inputs=[
            {"question": "What is LangChain?"},
            {"question": "What is LangSmith?"},
            {"question": "What is OpenAI?"},
            {"question": "What is Google?"},
            {"question": "What is Mistral?"},
        ],
        outputs=[
            {"answer": "A framework for building LLM applications"},
            {"answer": "A platform for observing and evaluating LLM applications"},
            {"answer": "A company that creates Large Language Models"},
            {"answer": "A technology company known for search"},
            {"answer": "A company that creates Large Language Models"},
        ],
        dataset_id=dataset.id,
    )

def search_agent():
    agent_executor = AgentExecutor(agent=agent, tools=tools)
    result = agent_executor.invoke(
        {"input": "Who directed the 2023 film Oppenheimer and what is their age in days?"}
    )
    return result

if __name__=='__main__':
    evaluator = search_agent()
    print(evaluator)
    # verbose()
    # debug()

2.2.4 LangSmith

LangSmith允许使用者通过执行具体步骤监控和评估LLM应用。LangSmith无缝地集成了LangChain，所以可以用LangSmith检测你建立Chains的每一个步骤。
使用LangSmith步骤如下：
1）第一步：在 LangSmith上注册一个langsmith_api_key
2) 第二步：做如下几个配置，这样运行任何一个langchain代码，就可以在langsmith网页中可以看到大模型的每一个步骤流程，首先我们需要配置的参数如下：
在这里插入图片描述
配置好参数后，我们就可以写我们的代码，每次运行trace就可以在我们的LangSmith上查看，
我们从LangSmith里可以看到就有我们刚建立的工程了，如下：

点进去就可以看到我们的刚刚在配置里设置的工程LANGCHAIN_PROJECT='langsmith_test’这个工程，结果如下：
在这里插入图片描述
点击进去，就可以看到我们刚执行的代码具体的一个中间结果了，如下所示：

这样我们就很清晰的看到每一个步骤的执行结果，当我们构建的应用较复杂，LangSmith是一个很好的调试可视化结果,对大模型的每一步的中间结果的输出。