Introducción a LangChain.js: Construyendo Aplicaciones Prácticas de LLM
Por Jake Morrison LangChain.js es una de esas herramientas. Proporciona una forma estructurada de construir aplicaciones impulsadas por modelos de lenguaje grande (LLMs) utilizando JavaScript o TypeScript. Si estás trabajando con LLMs en el ecosistema de JavaScript, entender LangChain.js es fundamental. Esta guía te llevará a través de pasos prácticos y aplicables para comenzar y construir aplicaciones reales.
¿Qué es LangChain.js y Por Qué Usarlo?
LangChain.js es una biblioteca diseñada para ayudar a los desarrolladores a crear aplicaciones impulsadas por LLMs. No reemplaza a los LLMs en sí, sino que proporciona una capa de abstracción y un conjunto de herramientas para encadenar diferentes llamadas a LLM, integrarse con otras fuentes de datos y gestionar interacciones complejas.
Piénsalo de esta manera: llamar directamente a una API de LLM es como usar una consulta de base de datos en bruto. LangChain.js proporciona un ORM (Object-Relational Mapper) para LLMs. Maneja patrones comunes como:
* **Cadenas:** Combinando múltiples llamadas a LLM u otros pasos en una secuencia.
* **Prompts:** Gestionando y formateando la entrada para los LLMs.
* **Agentes:** Permitendo a los LLMs tomar decisiones y usar herramientas.
* **Recuperación:** Integrando datos externos (tus documentos, bases de datos) con LLMs.
* **Memoria:** Dando a los LLMs una forma de recordar interacciones pasadas.
El principal beneficio de usar LangChain.js es un aumento en la productividad y mantenibilidad. Escribes menos código repetitivo, la lógica de tu aplicación se vuelve más clara y es más fácil cambiar proveedores de LLM o agregar nuevas características. Para cualquiera que esté construyendo con LLMs en JavaScript, LangChain.js ofrece ventajas significativas.
Configurando Tu Proyecto LangChain.js
Antes de escribir cualquier código, preparemos nuestro entorno. Necesitarás tener Node.js instalado.
1. **Crea un nuevo directorio de proyecto:**
“`bash
mkdir langchain-js-project
cd langchain-js-project
“`
2. **Inicializa un proyecto de Node.js:**
“`bash
npm init -y
“`
3. **Instala LangChain.js y un proveedor de LLM:**
Comenzaremos con OpenAI para nuestros ejemplos, pero LangChain.js es compatible con muchos otros (Hugging Face, Google, etc.).
“`bash
npm install langchain @openai/openai
“`
Si prefieres TypeScript:
“`bash
npm install langchain @openai/openai typescript @types/node ts-node
npx tsc –init
“`
Luego, actualiza `tsconfig.json` para incluir `”moduleResolution”: “node”` y `”esModuleInterop”: true`.
4. **Configura tu clave API:**
Necesitarás una clave API de OpenAI. Nunca incluyas claves API en tu código de forma estática. Usa variables de entorno.
Crea un archivo `.env` en la raíz de tu proyecto:
“`
OPENAI_API_KEY=YOUR_OPENAI_API_KEY
“`
Para cargar variables de entorno, instala `dotenv`:
“`bash
npm install dotenv
“`
Luego, en la parte superior de tu archivo principal de script (por ejemplo, `index.js` o `src/index.ts`):
“`javascript
require(‘dotenv’).config();
“`
o para TypeScript/ESM:
“`typescript
import ‘dotenv/config’;
“`
Ahora estás listo para comenzar a construir con LangChain.js.
Tu Primer Llamada a LLM con LangChain.js
Hagamos una llamada simple a un LLM.
“`javascript
// index.js
require(‘dotenv’).config();
const { OpenAI } = require(‘langchain/llms/openai’);
async function simpleLLMCall() {
const model = new OpenAI({ temperature: 0.7 }); // temperature controla la aleatoriedad
const prompt = “¿Cuál es la capital de Francia?”;
const result = await model.call(prompt);
console.log(result);
}
simpleLLMCall();
“`
Para ejecutar esto: `node index.js`.
Deberías ver “París.” o una salida similar. Esta es la interacción más básica. LangChain.js envuelve la llamada a la API de OpenAI, haciéndola consistente con otros proveedores de LLM.
Trabajando con Prompts: Plantillas y Variables
Incorporar prompts directamente en tu código puede volverse desordenado. LangChain.js proporciona `PromptTemplate` para gestionar prompts de manera efectiva.
“`javascript
// promptExample.js
require(‘dotenv’).config();
const { OpenAI } = require(‘langchain/llms/openai’);
const { PromptTemplate } = require(‘langchain/prompts’);
async function templatedPrompt() {
const model = new OpenAI({ temperature: 0.7 });
const template = “¿Cuál es un buen nombre para una empresa que fabrica {product}?”;
const prompt = new PromptTemplate({
template: template,
inputVariables: [“product”],
});
const formattedPrompt = await prompt.format({ product: “calcetines coloridos” });
console.log(“Prompt Formateado:”, formattedPrompt);
const result = await model.call(formattedPrompt);
console.log(“Resultado de LLM:”, result);
}
templatedPrompt();
“`
Ejecuta esto con `node promptExample.js`.
Esto demuestra cómo `PromptTemplate` te permite definir prompts con marcadores de posición (`{product}`) que puedes llenar de manera dinámica. Esto es crucial para construir aplicaciones flexibles.
Cadenas: Conectando Llamadas de LLM y Lógica
Las cadenas son donde LangChain.js realmente brilla. Permiten combinar múltiples pasos, incluidas llamadas a LLM, en un solo flujo de trabajo coherente.
Cadena LLM Simple
El `LLMChain` es la cadena más básica. Toma un `PromptTemplate` y un LLM, luego formatea el prompt y lo pasa al LLM.
“`javascript
// llmChainExample.js
require(‘dotenv’).config();
const { OpenAI } = require(‘langchain/llms/openai’);
const { PromptTemplate } = require(‘langchain/prompts’);
const { LLMChain } = require(‘langchain/chains’);
async function simpleLLMChain() {
const model = new OpenAI({ temperature: 0.7 });
const template = “¿Cuál es la mejor {activity} para hacer en {city}?“;
const prompt = new PromptTemplate({
template: template,
inputVariables: [“activity”, “city”],
});
const chain = new LLMChain({ llm: model, prompt: prompt });
const result = await chain.call({ activity: “comida”, city: “Roma” });
console.log(“Resultado de la Cadena:”, result);
// El objeto resultado contendrá una propiedad ‘text’ con la salida del LLM.
}
simpleLLMChain();
“`
Ejecuta con `node llmChainExample.js`.
Nota cómo `chain.call()` toma un objeto con las variables de entrada y se encarga de formatear el prompt y llamar al LLM. Esta es una forma más limpia de interactuar con tu LLM.
Cadenas Secuenciales: Flujos de Trabajo de Múltiples Pasos
A veces necesitas realizar múltiples llamadas a LLM en secuencia, donde la salida de una llamada se convierte en la entrada para la siguiente. Aquí es donde `SimpleSequentialChain` resulta útil.
“`javascript
// sequentialChainExample.js
require(‘dotenv’).config();
const { OpenAI } = require(‘langchain/llms/openai’);
const { PromptTemplate } = require(‘langchain/prompts’);
const { LLMChain, SimpleSequentialChain } = require(‘langchain/chains’);
async function multiStepChain() {
const model = new OpenAI({ temperature: 0.7 });
// Cadena 1: Generar un nombre de empresa
const nameTemplate = “¿Cuál es un buen nombre para una empresa que fabrica {product}?“;
const namePrompt = new PromptTemplate({
template: nameTemplate,
inputVariables: [“product”],
});
const nameChain = new LLMChain({ llm: model, prompt: namePrompt });
// Cadena 2: Describir la empresa
const descriptionTemplate = “Escribe un lema de marketing corto y atractivo para una empresa llamada {companyName}.”;
const descriptionPrompt = new PromptTemplate({
template: descriptionTemplate,
inputVariables: [“companyName”],
});
const descriptionChain = new LLMChain({ llm: model, prompt: descriptionPrompt });
// Combínalas en una cadena secuencial
const overallChain = new SimpleSequentialChain({
chains: [nameChain, descriptionChain],
verbose: true, // Establecido en true para ver los pasos intermedios
});
const result = await overallChain.run(“zapatos ecológicos”);
console.log(“Resultado General:”, result);
}
multiStepChain();
“`
Ejecuta con `node sequentialChainExample.js`.
El `SimpleSequentialChain` toma la salida de `nameChain` y la utiliza automáticamente como entrada (`companyName`) para `descriptionChain`. Este patrón es extremadamente poderoso para descomponer tareas complejas. LangChain.js facilita esto.
Generación Aumentada por Recuperación (RAG): Usando Tus Propios Datos
Los LLMs son potentes, pero su conocimiento está limitado a sus datos de entrenamiento. Para aplicaciones que requieren información actual o conocimiento específico de dominio (los documentos de tu empresa, por ejemplo), necesitas aumentar el conocimiento del LLM con datos externos. Esto se llama Generación Aumentada por Recuperación (RAG).
La idea principal de RAG es:
1. **Cargar Datos:** Obtén tus documentos (PDFs, archivos de texto, páginas web).
2. **Dividir Datos:** Parte documentos grandes en trozos más pequeños y manejables.
3. **Incrustar Datos:** Convierte estos trozos en representaciones numéricas (incrustaciones) utilizando un modelo de incrustación.
4. **Almacenar Datos:** Guarda estas incrustaciones en una base de datos vectorial.
5. **Recuperar:** Cuando un usuario hace una pregunta, incrusta la pregunta, busca en la base de datos vectorial trozos de documentos similares.
6. **Aumentar el Prompt:** Añade estos trozos recuperados al prompt del LLM.
7. **Generar:** El LLM utiliza este prompt aumentado para generar una respuesta más informada.
LangChain.js proporciona componentes para cada uno de estos pasos.
Paso 1: Cargando Documentos
LangChain.js tiene varios cargadores de documentos. Usaremos un `TextLoader`.
“`javascript
// ragExample.js – Parte 1: Carga de Documentos
require(‘dotenv’).config();
const { TextLoader } = require(‘langchain/document_loaders/fs/text’);
async function loadDocuments() {
// Crea un archivo de texto de ejemplo para la demostración
const fs = require(‘fs’);
fs.writeFileSync(‘my_document.txt’, `
El rápido zorro marrón salta sobre el perro perezoso.
Este documento habla sobre varios animales y sus comportamientos.
Los perros son conocidos por su lealtad y diversión.
Los zorros son criaturas astutas y solitarias.
Los gatos disfrutan de dormir la siesta y cazar ratones.
`);
const loader = new TextLoader(“my_document.txt”);
const docs = await loader.load();
console.log(“Documentos Cargados:”, docs);
// Cada documento tendrá contenido de página y metadatos
}
loadDocuments();
“`
Paso 2: Dividiendo Documentos
Los documentos grandes deben dividirse en trozos más pequeños para que quepan dentro de la ventana de contexto del LLM y para mejorar la relevancia de la recuperación.
“`javascript
// ragExample.js – Parte 2: División
require(‘dotenv’).config();
const { TextLoader } = require(‘langchain/document_loaders/fs/text’);
const { RecursiveCharacterTextSplitter } = require(‘langchain/text_splitter’);
async function splitDocuments() {
// (Suponiendo que my_document.txt ya ha sido creado en la Parte 1)
const loader = new TextLoader(“my_document.txt”);
const docs = await loader.load();
const splitter = new RecursiveCharacterTextSplitter({
chunkSize: 100, // Máx. de caracteres por trozo
chunkOverlap: 20, // Solapamiento entre trozos para mantener el contexto
});
const splitDocs = await splitter.splitDocuments(docs);
console.log(“Documentos Divididos:”, splitDocs);
}
splitDocuments();
“`
Paso 3 & 4: Incrustar y Almacenar Documentos (Almacén Vectorial)
Aquí es donde entran las incrustaciones y las bases de datos vectoriales. Usaremos incrustaciones de OpenAI y `HNSWLib` (un almacén vectorial local en memoria) por simplicidad. Para producción, usarías una base de datos vectorial dedicada como Pinecone, Chroma, Weaviate, etc.
“`javascript
// ragExample.js – Parte 3: Incrustaciones y Almacén Vectorial
require(‘dotenv’).config();
const { OpenAIEmbeddings } = require(‘langchain/embeddings/openai’);
const { HNSWLib } = require(‘langchain/vectorstores/hnswlib’);
const { RecursiveCharacterTextSplitter } = require(‘langchain/text_splitter’);
const { TextLoader } = require(‘langchain/document_loaders/fs/text’);
const { OpenAI } = require(‘langchain/llms/openai’);
const { RetrievalQAChain } = require(‘langchain/chains’);
async function ragApplication() {
// 1. Cargar y Dividir Documentos
const fs = require(‘fs’);
fs.writeFileSync(‘my_document.txt’, `
El rápido zorro marrón salta sobre el perro perezoso.
Este documento habla sobre varios animales y sus comportamientos.
Los perros son conocidos por su lealtad y diversión.
Los zorros son criaturas astutas y solitarias.
Los gatos disfrutan de dormir la siesta y cazar ratones.
Un grupo de gatos se llama un clowder.
`);
const loader = new TextLoader(“my_document.txt”);
const rawDocs = await loader.load();
const splitter = new RecursiveCharacterTextSplitter({
chunkSize: 100,
chunkOverlap: 20,
});
const docs = await splitter.splitDocuments(rawDocs);
// 2. Crear Incrustaciones y Almacenar en el Almacén Vectorial
const embeddings = new OpenAIEmbeddings();
const vectorStore = await HNSWLib.fromDocuments(docs, embeddings);
// 3. Crear un Recuperador
const retriever = vectorStore.asRetriever();
// 4. Crear la Cadena de Recuperación QA
const model = new OpenAI({ temperature: 0 });
const chain = RetrievalQAChain.fromLLM(model, retriever);
// 5. Hacer una pregunta
const question = “¿Cómo se llama un grupo de gatos?”;
const result = await chain.call({ query: question });
console.log(“Respuesta RAG:”, result.text);
const anotherQuestion = “Cuéntame sobre los zorros.”;
const anotherResult = await chain.call({ query: anotherQuestion });
console.log(“Otra Respuesta RAG:”, anotherResult.text);
}
ragApplication();
“`
Ejecuta con `node ragExample.js`.
Este ejemplo reúne todas las piezas de RAG. La `RetrievalQAChain` abstrae el proceso de recuperar documentos relevantes y usarlos para responder una pregunta. Esta es una forma práctica de construir chatbots o sistemas de preguntas y respuestas sobre tus datos específicos utilizando LangChain.js.
Agentes: LLMs Usando Herramientas
Los agentes permiten a los LLMs tomar decisiones sobre qué herramientas usar y en qué orden, según la entrada del usuario. Esto permite interacciones más dinámicas y complejas. Las herramientas pueden ser cualquier cosa: un motor de búsqueda, una calculadora, una llamada API a tus sistemas internos, o incluso otra cadena LLM.
Vamos a crear un agente simple que pueda realizar cálculos utilizando una herramienta `Calculator`.
“`javascript
// agentExample.js
require(‘dotenv’).config();
const { OpenAI } = require(‘langchain/llms/openai’);
const { initializeAgentExecutorWithOptions } = require(‘langchain/agents’);
const { Calculator } = require(‘langchain/tools/calculator’);
async function runAgent() {
const model = new OpenAI({ temperature: 0 });
const tools = [new Calculator()];
// Inicializar el ejecutor del agente
const executor = await initializeAgentExecutorWithOptions(tools, model, {
agentType: “openai-functions”, // Usar la función de llamada de OpenAI
verbose: true, // Ver el proceso de pensamiento del agente
});
console.log(“Llamando al agente con una pregunta matemática simple…”);
const result1 = await executor.call({ input: “¿Cuánto es 123 más 456?” });
console.log(“Resultado del Agente 1:”, result1.output);
console.log(“\nLlamando al agente con una pregunta más compleja…”);
const result2 = await executor.call({ input: “¿Cuál es la raíz cuadrada de 625 multiplicada por 3?” });
console.log(“Resultado del Agente 2:”, result2.output);
}
runAgent();
“`
Ejecuta con `node agentExample.js`.
Con `verbose: true`, verás los “pensamientos” del agente: identifica que se necesita un cálculo, usa la herramienta `Calculator`, y luego proporciona la respuesta. Este es un patrón poderoso para construir aplicaciones que van más allá de una simple generación de texto. LangChain.js simplifica la configuración de estos agentes.
Memoria: Manteniendo el Contexto de la Conversación
Por defecto, los LLMs son sin estado. Cada llamada API es independiente. Para aplicaciones conversacionales, el LLM necesita recordar interacciones pasadas. LangChain.js proporciona varios tipos de memoria para lograr esto.
`ConversationBufferMemory` es una opción común, que almacena el historial de conversación en bruto.
“`javascript
// memoryExample.js
require(‘dotenv’).config();
const { OpenAI } = require(‘langchain/llms/openai’);
const { ConversationChain } = require(‘langchain/chains’);
const { ConversationBufferMemory } = require(‘langchain/memory’);
async function conversationalApp() {
const model = new OpenAI({ temperature: 0.7 });
const memory = new ConversationBufferMemory();
const chain = new ConversationChain({ llm: model, memory: memory });
console.log(“Iniciando conversación…”);
let result1 = await chain.call({ input: “Hola, mi nombre es Jake.” });
console.log(“Usuario: Hola, mi nombre es Jake.”);
console.log(“IA:”, result1.response);
let result2 = await chain.call({ input: “¿Cuál es mi nombre?” });
console.log(“Usuario: ¿Cuál es mi nombre?”);
console.log(“IA:”, result2.response);
let result3 = await chain.call({ input: “Cuéntame un dato curioso sobre JavaScript.” });
console.log(“Usuario: Cuéntame un dato curioso sobre JavaScript.”);
console.log(“IA:”, result3.response);
}
conversationalApp();
“`
Ejecuta con `node memoryExample.js`.
La `ConversationBufferMemory` mantiene el historial de chat, permitiendo que el LLM responda correctamente a la pregunta “¿Cuál es mi nombre?” basada en el turno anterior. LangChain.js ofrece otros tipos de memoria para casos de uso más avanzados, como resumir conversaciones o almacenar solo partes específicas.
Consejos Prácticos para el Desarrollo con LangChain.js
1. **Empieza Simple:** No intentes construir un agente complejo con múltiples herramientas y memoria de inmediato. Comienza con llamadas simples a LLM y `LLMChain`.
2. **Usa `verbose: true`:** Al depurar cadenas o agentes, configurar `verbose: true` es invaluable. Te muestra los pasos intermedios, los mensajes enviados y las respuestas recibidas, lo que te ayuda a entender por qué tu cadena podría no estar funcionando como se esperaba.
3. **Administra las Claves API de Forma Segura:** Siempre utiliza variables de entorno para tus claves API. Nunca las commits en el control de versiones.
4. **Entiende las Ventanas de Contexto:** Ten en cuenta los límites de tokens del LLM que has elegido. Prompts largos, historias de conversación extensas o muchos documentos recuperados pueden superar rápidamente estos límites. LangChain.js tiene herramientas para ayudar a gestionar esto, pero es importante estar al tanto.
5. **Experimenta con la `temperature`:** El parámetro `temperature` controla la aleatoriedad de la salida del LLM. Valores más altos (por ejemplo, 0.7-1.0) generan respuestas más creativas y menos deterministas. Valores más bajos (por ejemplo, 0.0-0.3) son más fácticos y consistentes. Ajusta esto según las necesidades de tu aplicación.
6. **Explora la Documentación:** La documentación de LangChain.js es completa. Si buscas un cargador, cadena o herramienta específica, lo más probable es que esté cubierta ahí.
7. **Considera Almacenes de Vectores en Producción:** Para aplicaciones RAG del mundo real, reemplaza `HNSWLib` con una base de datos vectorial persistente como Pinecone, Chroma o Weaviate. Esto te permitirá escalar y almacenar grandes cantidades de datos.
8. **Manejo de Errores:** Implementa un manejo de errores efectivo para las llamadas API, especialmente en entornos de producción. Problemas de red, límites de tasa o entradas inválidas pueden causar fallas.
Preguntas Frecuentes sobre LangChain.js
Q1: ¿LangChain.js es solo para modelos de OpenAI?
No, LangChain.js admite una amplia gama de proveedores de LLM, incluidos OpenAI, modelos de Hugging Face (a través de `HuggingFaceHub` o `HuggingFaceInference`), Google (por ejemplo, `GoogleGenerativeAI`), Anthropic y muchos más. Las abstracciones centrales de LangChain.js te permiten cambiar los proveedores de LLM con cambios mínimos en el código.
Q2: ¿Cuál es la diferencia entre `model.call()` y `chain.call()` o `chain.run()`?
`model.call()` es la forma más directa de interactuar con una única instancia de LLM, pasando un mensaje de texto en bruto. `chain.call()` se utiliza para cadenas y toma un objeto que contiene variables de entrada (que luego se formatean mediante un `PromptTemplate` si se usa dentro de la cadena). `chain.run()` es un método de conveniencia para cadenas que solo tienen una variable de entrada y devuelve directamente el texto de salida. Para cadenas más complejas con múltiples entradas/salidas, se prefiere `chain.call()`.
Q3: ¿Cómo puedo integrar LangChain.js con mi base de datos o API existente?
Puedes integrar LangChain.js con tus sistemas existentes creando herramientas personalizadas para los agentes. Una herramienta es esencialmente una función que toma una cadena de entrada y devuelve una cadena de salida. Puedes definir una herramienta que consulte tu base de datos, llame a una API interna o realice cualquier otra lógica personalizada, y luego hacer que esta herramienta esté disponible para tu agente de LangChain.js. Para RAG, puedes crear implementaciones personalizadas de `DocumentLoader` para cargar datos de tus fuentes de datos específicas.
Q4: ¿Cuándo debería usar LangChain.js en lugar de llamar directamente a las APIs de LLM?
Usa LangChain.js cuando necesites construir aplicaciones que involucren más de una sola llamada aislada a LLM. Si tu aplicación requiere:
* Razonamiento en múltiples pasos (cadenas).
* Integrar datos externos (RAG).
* Dar acceso a herramientas externas al LLM (agentes).
* Administrar el historial de conversación (memoria).
* Cambiar fácilmente los proveedores de LLM.
* Código más estructurado y mantenible.
Si solo estás haciendo un prompt único para pruebas, las llamadas API directas pueden ser más simples, pero para cualquier aplicación práctica, LangChain.js se vuelve rápidamente indispensable.
Conclusión
LangChain.js es un marco poderoso para construir aplicaciones sofisticadas de LLM en JavaScript y TypeScript. Al entender sus componentes fundamentales—LLMs, Prompts, Chains, Retrieval, Agents, y Memory—puedes construir sistemas inteligentes que van más allá de la simple generación de texto. Esta guía ha proporcionado un punto de partida práctico y accionable. Desde llamadas simples a LLM hasta complejas tuberías y agentes de RAG, LangChain.js ofrece las herramientas para hacer realidad tus ideas de automatización de IA. Empieza a experimentar, construye pequeños proyectos, y rápidamente descubrirás el potencial de LangChain.js en tu flujo de trabajo de desarrollo.
🕒 Published: