TechLead
Lección 5 de 18
5 min de lectura
LangChain

Agentes en LangChain

Crea agentes autónomos que pueden usar herramientas y tomar decisiones

¿Qué son los agentes?

Los agentes son sistemas autónomos que usan LLMs para decidir qué acciones tomar. A diferencia de las cadenas con pasos predefinidos, los agentes eligen dinámicamente sus acciones según la entrada del usuario y las herramientas disponibles. Pueden razonar, planificar y ejecutar tareas de varios pasos.

🛠️ Componentes de un agente

  • LLM: El motor de razonamiento que decide qué hacer
  • Herramientas: Funciones que el agente puede invocar para actuar
  • Prompt: Instrucciones que guían el comportamiento del agente
  • Memoria: Historial conversacional opcional

Crear herramientas

Las herramientas son funciones que los agentes pueden usar para interactuar con el mundo:

Define herramientas con esquemas de entrada para que el agente las llame de forma segura y predecible. 

import { tool } from "@langchain/core/tools";
import { z } from "zod";

// Simple calculator tool
const calculatorTool = tool(
  async ({ operation, a, b }) => {
    switch (operation) {
      case "add": return String(a + b);
      case "subtract": return String(a - b);
      case "multiply": return String(a * b);
      case "divide": return String(a / b);
      default: return "Unknown operation";
    }
  },
  {
    name: "calculator",
    description: "Performs basic arithmetic operations",
    schema: z.object({
      operation: z.enum(["add", "subtract", "multiply", "divide"]),
      a: z.number().describe("First number"),
      b: z.number().describe("Second number"),
    }),
  }
);

// Web search tool
const searchTool = tool(
  async ({ query }) => {
    // Implement actual search
    return `Search results for: ${query}`;
  },
  {
    name: "web_search",
    description: "Search the web for current information",
    schema: z.object({
      query: z.string().describe("The search query"),
    }),
  }
);

Herramientas integradas

LangChain incluye herramientas comunes para añadir búsqueda, Wikipedia o calculadora rápidamente. 

// Tavily Search (requires API key)
import { TavilySearchResults } from "@langchain/community/tools/tavily_search";
const searchTool = new TavilySearchResults({ maxResults: 3 });

// Wikipedia
import { WikipediaQueryRun } from "@langchain/community/tools/wikipedia_query_run";
const wikiTool = new WikipediaQueryRun({ topKResults: 3 });

// Calculator
import { Calculator } from "langchain/tools/calculator";
const calcTool = new Calculator();

Crear un agente

Crea un agente ReAct combinando un modelo con las herramientas a las que puede acceder. 

import { ChatOpenAI } from "@langchain/openai";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const model = new ChatOpenAI({
  modelName: "gpt-4",
  temperature: 0,
});

const tools = [calculatorTool, searchTool];

// Create a ReAct agent
const agent = createReactAgent({
  llm: model,
  tools,
});

// Run the agent
const result = await agent.invoke({
  messages: [{ role: "user", content: "What is 25 * 4, and then search for information about that number" }],
});

console.log(result.messages[result.messages.length - 1].content);

Agente con prompt personalizado

Personaliza el comportamiento del agente proporcionando un prompt de sistema que guíe su razonamiento. 

import { ChatPromptTemplate } from "@langchain/core/prompts";

const systemPrompt = `You are a helpful assistant that can use tools to answer questions.
Always explain your reasoning step by step.
If you're unsure, say so rather than making up information.`;

const agent = createReactAgent({
  llm: model,
  tools,
  messageModifier: systemPrompt,
});

Streaming de respuestas del agente

Transmite eventos del agente para mostrar pasos de razonamiento y llamadas a herramientas en tiempo real. 

const stream = await agent.stream({
  messages: [{ role: "user", content: "Search for the latest news about AI" }],
});

for await (const event of stream) {
  // Handle different event types
  if (event.agent) {
    console.log("Agent thinking:", event.agent.messages[0].content);
  }
  if (event.tools) {
    console.log("Tool called:", event.tools.messages[0].name);
  }
}

Llamadas de herramientas con function calling

El modelo puede solicitar ejecución de herramientas y tú devuelves el resultado para completar la respuesta. 

import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage, ToolMessage } from "@langchain/core/messages";

const model = new ChatOpenAI({ modelName: "gpt-4" });
const modelWithTools = model.bindTools([calculatorTool, searchTool]);

// Initial call
const response = await modelWithTools.invoke([
  new HumanMessage("What is 15 + 27?"),
]);

// Check for tool calls
if (response.tool_calls && response.tool_calls.length > 0) {
  const toolCall = response.tool_calls[0];

  // Execute the tool
  const toolResult = await calculatorTool.invoke(toolCall.args);

  // Send result back to model
  const finalResponse = await modelWithTools.invoke([
    new HumanMessage("What is 15 + 27?"),
    response,
    new ToolMessage({
      tool_call_id: toolCall.id,
      content: toolResult,
    }),
  ]);

  console.log(finalResponse.content);
}

Ejemplo de agente con múltiples herramientas

Combina varias herramientas para que el agente resuelva tareas de varios pasos seleccionando la adecuada. 

import { tool } from "@langchain/core/tools";
import { z } from "zod";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

// Define multiple tools
const getCurrentWeather = tool(
  async ({ city }) => {
    // Mock implementation
    return JSON.stringify({ city, temp: 72, condition: "sunny" });
  },
  {
    name: "get_weather",
    description: "Get current weather for a city",
    schema: z.object({ city: z.string() }),
  }
);

const getNews = tool(
  async ({ topic }) => {
    return `Latest news about ${topic}: [Mock news results]`;
  },
  {
    name: "get_news",
    description: "Get latest news about a topic",
    schema: z.object({ topic: z.string() }),
  }
);

const sendEmail = tool(
  async ({ to, subject, body }) => {
    console.log(`Email sent to ${to}`);
    return "Email sent successfully";
  },
  {
    name: "send_email",
    description: "Send an email to someone",
    schema: z.object({
      to: z.string().email(),
      subject: z.string(),
      body: z.string(),
    }),
  }
);

// Create agent with all tools
const agent = createReactAgent({
  llm: new ChatOpenAI({ modelName: "gpt-4", temperature: 0 }),
  tools: [getCurrentWeather, getNews, sendEmail],
});

// Agent will decide which tools to use
const result = await agent.invoke({
  messages: [{
    role: "user",
    content: "What's the weather in NYC? Then send an email to user@example.com with the weather report.",
  }],
});

⚠️ Seguridad del agente

Los agentes pueden tomar acciones reales. Implementa validación, rate limiting y pasos de confirmación para operaciones sensibles como enviar emails o hacer compras.

💡 Puntos clave

  • • Los agentes deciden dinámicamente qué herramientas usar según la tarea
  • • Las herramientas son funciones con esquemas que definen sus entradas
  • • Los agentes ReAct razonan paso a paso antes de actuar
  • • Usa streaming para feedback en tiempo real del progreso
  • • Valida siempre las acciones del agente en producción

📚 Más recursos

Continuar aprendiendo

Tutorial de React →Tutorial de Next.js →Tutorial de IA →