LangChain / RAG / Vector DBs · 课时

LangChain 智能体与工具概念

了解 LangChain 智能体如何进行推理并使用工具，完成超越简单问答的复杂任务。

LangChain 智能体与工具概念 是 CoddyKit 上的免费 LangChain / RAG / Vector DBs 课时。这是第 1 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 LangChain / RAG / Vector DBs 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 LangChain / RAG / Vector DBs 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

What are LangChain Agents?

Welcome to Agents! So far, you've learned to build chains that perform a fixed sequence of steps. But what if you need more flexibility?

LangChain Agents are systems that allow an LLM to dynamically decide which actions to take, observe the results, and then decide the next action. Think of them as giving the LLM a 'brain' to reason and 'hands' to interact with the world.

The Agent's Reasoning Loop

Agents operate on a continuous Observe-Think-Act loop:

Observe: The agent receives an input (your query) and the results of its last action.
Think: The LLM reasons about the current situation and decides what to do next.
Act: The agent performs an action, often by using a tool.

This loop continues until the agent determines it has enough information to answer your question or complete its task.

Introducing Tools

An LLM alone can only access the knowledge it was trained on. To perform actions in the real world or access up-to-date information, it needs Tools.

Tools are functions or APIs that an agent can call. They extend the LLM's capabilities, allowing it to:

Search the internet for current events.
Perform calculations.
Query databases.
Interact with other applications.

Anatomy of a Tool

Each tool needs a few key pieces of information for the agent to use it effectively:

Name: A unique identifier (e.g., 'Google Search').
Description: A clear explanation of what the tool does and when it should be used. This is crucial for the LLM's reasoning.
Input Schema: What kind of input the tool expects (e.g., a search query string, two numbers).

The LLM reads the descriptions to decide which tool is appropriate for a given step.

Common Built-in Tools

LangChain provides many ready-to-use tools. Here are a couple of popular examples:

SerpAPIWrapper: Allows the agent to perform Google searches. Useful for current information or specific data points.
LLMMathChain: Enables the agent to perform mathematical calculations. This is more reliable than asking the LLM to do complex math directly.

These tools are like plugins that give your agent superpowers!

Setting Up a Simple Agent

To create an agent, you typically need:

An LLM (e.g., ChatOpenAI).
A list of Tools the agent can use.
An Agent Type or a prompt that defines how the agent should reason (e.g., ReAct framework).

Let's prepare these components to build an agent that can do math!

Agent in Action: Calculator

Here's a Python example of an agent using a custom 'Calculator' tool. The LLM decides when to use the tool based on the question.

Note: For a real application, replace eval() with a secure math parser.

import os
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent, Tool
from langchain import hub

# Ensure OPENAI_API_KEY is set in your environment variables

def get_calculator_tool():
    """A simple calculator tool."""
    def calculate(expression: str) -> str:
        try:
            # DANGER: In real apps, use safer math parsers!
            return str(eval(expression))
        except Exception as e:
            return f"Error: {e}"

    return Tool(
        name="Calculator",
        func=calculate,
        description="Useful for when you need to answer questions about math. Input should be a mathematical expression."
    )

def main():
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    tools = [get_calculator_tool()]
    prompt = hub.pull("hwchase17/react") # ReAct agent prompt

    agent = create_react_agent(llm, tools, prompt)
    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

    print("--- Agent Running ---")
    result = agent_executor.invoke({"input": "What is 123 + 456?"})
    print("\n--- Agent Result ---")
    print(result["output"])

if __name__ == "__main__":
    main()

Tracing Agent's Thought Process

When you run an agent with verbose=True, LangChain shows you the agent's internal monologue:

Thought: The LLM's reasoning about the current situation.
Action: The tool it decides to use and its input.
Observation: The result returned by the tool.

This trace helps you understand how the agent arrived at its answer and debug its behavior.

Different Agent Types

LangChain supports various agent types, each with a specific reasoning strategy:

zero-shot-react-description: A general-purpose agent that uses the ReAct framework. It relies heavily on tool descriptions.
OpenAIFunctionsAgent: Leverages OpenAI's native function calling capabilities, often leading to more robust and concise tool usage.
Others exist for specific use cases or models.

Choosing the right agent type depends on your LLM and task complexity.

Agent Limitations & Considerations

While powerful, agents have limitations:

Cost & Latency: Multiple LLM calls and tool invocations can increase cost and response time.
Reliability: Agents can still 'hallucinate' or misuse tools if descriptions aren't precise or the LLM struggles with complex reasoning.
Security: Tools that interact with external systems (like eval() or APIs) need careful handling to prevent vulnerabilities.

Design your tools and prompts carefully!

Agent Concepts Check

Which of the following statements about LangChain Agents and Tools are TRUE?

Recap: The Power of Agents

You've learned that LangChain Agents empower LLMs to move beyond simple question-answering by enabling them to:

Reason dynamically through an 'Observe-Think-Act' loop.
Utilize Tools to interact with external data and services.
Perform complex tasks that require multiple steps and external interactions.

This combination makes agents incredibly versatile for building intelligent applications!

常见问题解答

「LangChain 智能体与工具概念」课时是免费的吗？

是的 — 「LangChain 智能体与工具概念」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 LangChain / RAG / Vector DBs 课程的其余内容，请升级到 CoddyKit PRO。 LangChain / RAG / Vector DBs 课程共包含 4 节课。

「LangChain 智能体与工具概念」这节课中我会学到什么？

了解 LangChain 智能体如何进行推理并使用工具，完成超越简单问答的复杂任务。你通过在浏览器中直接运行的动手代码来练习 LangChain / RAG / Vector DBs，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 LangChain / RAG / Vector DBs 需要有经验吗？

无需任何先前经验。CoddyKit 上的 LangChain / RAG / Vector DBs 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 1 节课，共 4 节。

「LangChain 智能体与工具概念」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 LangChain / RAG / Vector DBs 课中编写并运行代码吗？

能。每节 LangChain / RAG / Vector DBs 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 LangChain / RAG / Vector DBs