Agentes y conceptos de herramientas de LangChain
Comprenda cómo los agentes de LangChain pueden razonar y utilizar herramientas para realizar tareas complejas más allá de responder preguntas sencillas.
Agentes y conceptos de herramientas de LangChain es una lección gratuita de LangChain / RAG / Vector DBs en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de LangChain / RAG / Vector DBs, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de LangChain / RAG / Vector DBs incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
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!
Aprende LangChain / RAG / Vector DBs con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 12
- Lecciones
- 48
Preguntas frecuentes
¿La lección «Agentes y conceptos de herramientas de LangChain» es gratis?
Sí — el texto completo de «Agentes y conceptos de herramientas de LangChain» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de LangChain / RAG / Vector DBs, actualiza a CoddyKit PRO. El curso de LangChain / RAG / Vector DBs incluye 4 lecciones en total.
¿Qué aprenderé en «Agentes y conceptos de herramientas de LangChain»?
Comprenda cómo los agentes de LangChain pueden razonar y utilizar herramientas para realizar tareas complejas más allá de responder preguntas sencillas. Practicas LangChain / RAG / Vector DBs con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar LangChain / RAG / Vector DBs?
No se requiere experiencia previa. LangChain / RAG / Vector DBs en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Agentes y conceptos de herramientas de LangChain»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de LangChain / RAG / Vector DBs?
Sí. Cada lección de LangChain / RAG / Vector DBs incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Agentes y conceptos de herramientas de LangChain
- Construcción de flujos de trabajo RAG multiagente
- Integración de API externas como herramientas
- Memoria y estado en RAG agéntico