Crear un Agente de IA con LangChain y Node.js (2026)

Los agentes de IA son la pieza central del desarrollo moderno. En este tutorial vas a construir uno desde cero que puede buscar en internet, consultar documentos y ejecutar acciones.

¿Qué vamos a construir?

Un agente que:

1. Recibe una pregunta del usuario
2. Decide qué herramientas usar (búsqueda web, base de conocimiento, calculadora)
3. Ejecuta las herramientas necesarias
4. Sintetiza una respuesta final

Stack: Node.js + TypeScript + LangChain.js + OpenAI GPT-4.1

Requisitos previos

• Node.js 20+
• Una API key de OpenAI
• Conocimientos básicos de TypeScript

Paso 1: Setup del proyecto

mkdir mi-agente-ia && cd mi-agente-ia
npm init -y
npm install langchain @langchain/openai @langchain/community dotenv
npm install -D typescript @types/node
npx tsc --init

Crea un .env:

OPENAI_API_KEY=sk-...

Paso 2: El agente básico

// src/agent.ts
import { ChatOpenAI } from '@langchain/openai';
import { AgentExecutor, createToolCallingAgent } from 'langchain/agents';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { Calculator } from '@langchain/community/tools/calculator';
import 'dotenv/config';

const llm = new ChatOpenAI({
  model: 'gpt-4.1-mini',
  temperature: 0,
});

const tools = [new Calculator()];

const prompt = ChatPromptTemplate.fromMessages([
  ['system', 'Eres un asistente útil. Usa las herramientas disponibles cuando sea necesario.'],
  ['human', '{input}'],
  ['placeholder', '{agent_scratchpad}'],
]);

const agent = createToolCallingAgent({ llm, tools, prompt });
const executor = new AgentExecutor({ agent, tools });

const result = await executor.invoke({
  input: '¿Cuánto es 15% de 2.340€?',
});

console.log(result.output);
// → "El 15% de 2.340€ es 351€"

El agente decide solo que necesita la calculadora, la usa, y formula la respuesta.

Esta selección automática de herramientas funciona gracias al function calling. Si quieres entender cómo definir herramientas, manejar respuestas y conectar la IA con APIs externas sin LangChain, consulta el tutorial de function calling en OpenAI y Claude.

Paso 3: Añadir búsqueda web

import { TavilySearch } from '@langchain/community/tools/tavily_search';

const searchTool = new TavilySearch({
  apiKey: process.env.TAVILY_API_KEY,
  maxResults: 3,
});

const tools = [new Calculator(), searchTool];

Ahora el agente puede buscar información actualizada en internet.

Paso 4: RAG — Consultar tus propios documentos

Esta es la killer feature. El agente puede consultar una base de conocimiento propia.

import { OpenAIEmbeddings } from '@langchain/openai';
import { MemoryVectorStore } from 'langchain/vectorstores/memory';
import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
import { createRetrieverTool } from 'langchain/tools/retriever';

// 1. Cargar y dividir documentos
const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200,
});

const docs = await splitter.createDocuments([
  'Tu documentación interna va aquí...',
  'Políticas de la empresa, FAQs, etc.',
]);

// 2. Crear vectorstore
const vectorStore = await MemoryVectorStore.fromDocuments(
  docs,
  new OpenAIEmbeddings()
);

// 3. Crear herramienta de retrieval
const retrieverTool = createRetrieverTool(vectorStore.asRetriever(), {
  name: 'knowledge_base',
  description: 'Busca información en la base de conocimiento interna.',
});

const tools = [new Calculator(), searchTool, retrieverTool];

Ahora el agente tiene 3 herramientas y elige cuál usar según la pregunta.

Paso 5: Memoria conversacional

import { BufferMemory } from 'langchain/memory';

const memory = new BufferMemory({
  memoryKey: 'chat_history',
  returnMessages: true,
});

const executor = new AgentExecutor({
  agent,
  tools,
  memory,
});

// Primera pregunta
await executor.invoke({ input: 'Busca el precio de GPT-4.1' });
// Segunda pregunta (recuerda el contexto)
await executor.invoke({ input: '¿Y cuánto costaría procesar 1M de tokens?' });

Paso 6: API REST con Express

import express from 'express';

const app = express();
app.use(express.json());

app.post('/chat', async (req, res) => {
  const { message } = req.body;
  const result = await executor.invoke({ input: message });
  res.json({ response: result.output });
});

app.listen(3000, () => console.log('Agente escuchando en :3000'));

Arquitectura final

Usuario → API REST → AgentExecutor → LLM (GPT-4.1)
                                        ↓
                              ¿Qué herramienta uso?
                              ├── Calculator
                              ├── TavilySearch (web)
                              └── KnowledgeBase (RAG)
                                        ↓
                              Respuesta sintetizada

Cómo Desplegar un Agente LangChain en Producción

1. Usa GPT-4.1 mini para el 90% de casos — es 5x más barato y suficiente para la mayoría de agentes
2. Limita las iteraciones — maxIterations: 5 en el executor para evitar loops infinitos
3. Logging — Activa verbose: true para ver qué decide el agente en cada paso
4. Fallback — Si el agente falla, devuelve una respuesta por defecto en vez de un error
5. Rate limiting — Implementa cola de peticiones para no exceder límites de la API. Si tu agente recibe errores 429, aquí explico cómo diagnosticarlos y solucionarlos
6. Context length — Si las respuestas se truncan o el agente falla con documentos largos, revisa cómo solucionar el error context length exceeded

¿Cuánto cuesta ejecutar este agente?

Con GPT-4.1 mini y un promedio de 3 tool calls por consulta:

• ~2.000 tokens por consulta (input + output)
• $0.003 por consulta
• 1.000 consultas/día = ~$3/día = ~$90/mes

Con GPT-4.1 nano sería ~$15/mes para el mismo volumen. Consulta la calculadora de precios de IA para comparar todos los modelos. Si quieres usar APIs sin pagar, mira cómo usar la API de ChatGPT y Claude gratis.

¿Prefieres un chatbot más sencillo? Sigue mi tutorial para crear un chatbot RAG con OpenAI.

---

Este es el tipo de proyecto que construyo profesionalmente. Mira cómo apliqué Gemini y GPT en un ecosistema real de IA para reuniones con transcripción, diarización y generación de tickets automática. Si necesitas un agente o integración de IA para tu empresa, consulta mis servicios de desarrollo.