Introduction

LangChain is one of the frameworks that stands at the forefront in building applications that use large language models (LLMs).

Initially, it was gaining traction in Python ecosystem, but now it has equally good support in JavaScript and TypeScript, making it suitable for Node.js and even browser applications.

In this article, we’ll deep dive with JavaScript developers for an overview of LangChain, detailing its concepts, use cases and providing code snippets to help you get started.

What is LangChain?

LangChain is a framework that focuses on building applications with LLMs more efficiently. Rather than the traditional way of calling a model with a prompt, LangChain provides a set of abstractions and utilities to:

• Manage prompts effectively

• Chain multiple calls and logic together

• Integrate with external APIs and data sources

• Enable memory (context persistence)

• Build production-ready applications like chatbots, agents, and knowledge retrieval systems

Think of LangChain as the middleware between your application and LLM APIs (like OpenAI, Anthropic, or Hugging Face).

If you’re a NodeJS developer, think of LangChain as ExpressJS for LLMs.

Installing LangChain

To start with LangChain in JavaScript/TypeScript:

npm install langchain openai

# Optionally, install other integrations as needed:
npm install @pinecone-database/pinecone @azure/storage-blob

Basic Usage

Example: Calling OpenAI with LangChain

import { ChatOpenAI } from 'langchain/chat_models/openai';
import { HumanMessage } from 'langchain/schema';

const model = new ChatOpenAI({
  openAIApiKey: process.env.OPENAI_API_KEY,
  temperature: 0.7,
});

async function run() {
  const response = await model.call([new HumanMessage('Write a short poem about JavaScript.')]);
  console.log(response.content);
}

run();

Here’s what’s happening:

• ChatOpenAI is a wrapper for OpenAI’s GPT models.

• HumanMessage represents user input.

• The model call returns a structured response object.

Chains

Chains allow you to link together multiple components (LLMs, prompts, tools, APIs) into a pipeline.

Example: Simple LLMChain

import { ChatOpenAI } from 'langchain/chat_models/openai';
import { PromptTemplate } from 'langchain/prompts';
import { LLMChain } from 'langchain/chains';

const model = new ChatOpenAI({ openAIApiKey: process.env.OPENAI_API_KEY });

const prompt = new PromptTemplate({
  template: 'Translate the following text to French: {text}',

  inputVariables: ['text'],
});

const chain = new LLMChain({ llm: model, prompt });

async function run() {
  const res = await chain.call({ text: 'Hello, how are you?' });
  console.log(res.text);
}

run();

• PromptTemplate defines a reusable structured prompt.

• LLMChain executes the template + LLM as a single unit.

Memory

LLMs don’t remember past interactions by default. LangChain provides memory modules to maintain context.

Example: Conversation with Memory

import { ConversationChain } from 'langchain/chains';
import { ChatOpenAI } from 'langchain/chat_models/openai';
import { BufferMemory } from 'langchain/memory';

const model = new ChatOpenAI({
  openAIApiKey: process.env.OPENAI_API_KEY,
  temperature: 0,
});

const memory = new BufferMemory();

const chain = new ConversationChain({ llm: model, memory });

async function run() {
  await chain.call({ input: 'Hi, I’m Utkarsh.' });
  const res = await chain.call({ input: 'What’s my name?' });
  console.log(res.response);
}

run();

Here, BufferMemory stores previous interactions, so the model can recall “Utkarsh.”

Retrieval and Vector Stores

LangChain enables connecting LLMs with external knowledge bases using embeddings and vector databases (like Pinecone, Weaviate, or Chroma).

Example: Simple Retrieval

import { OpenAIEmbeddings } from 'langchain/embeddings/openai';
import { MemoryVectorStore } from 'langchain/vectorstores/memory';

const embeddings = new OpenAIEmbeddings({ openAIApiKey: process.env.OPENAI_API_KEY });

async function run() {
  const store = await MemoryVectorStore.fromTexts(
    [
      'JavaScript is a versatile programming language.',
      'LangChain helps connect LLMs with data.',
      'Node.js allows running JS on the server.',
    ],
    ['JS', 'LangChain', 'Node'],
    embeddings
  );

  const result = await store.similaritySearch('What is LangChain?', 1);
  console.log(result);
}

run();

This creates embeddings for your documents and enables semantic search.

Agents

Agents are LLM-powered decision makers. They choose which tools to use (APIs, functions, search engines) to answer a query.

Example: Simple Tool-Using Agent

import { initializeAgentExecutorWithOptions } from 'langchain/agents';
import { ChatOpenAI } from 'langchain/chat_models/openai';
import { SerpAPI } from 'langchain/tools';

const model = new ChatOpenAI({ openAIApiKey: process.env.OPENAI_API_KEY });

const tool = new SerpAPI(process.env.SERPAPI_API_KEY);

async function run() {
  const executor = await initializeAgentExecutorWithOptions(
    [tool],
    model,
    { agentType: 'chat-zero-shot-react-description' }
  );

  const result = await executor.call({ input: 'What’s the weather in New York today?' });
  console.log(result.output);
}

run();

Here, the agent dynamically decides to use the SerpAPI search tool to fetch live information.

Popular Use Cases for JS Developers

• Chatbots & Virtual Assistants – with context memory and API access

• Document Q&A – retrieve answers from PDFs, docs, or knowledge bases

• Code Generation – build AI coding assistants

• Workflow Automation – LLM + tools for dynamic workflows

• Customer Support Bots – integrate with CRM and ticketing systems

Best Practices

• Prompt Engineering – Define clear, structured prompts.

• Control Costs – Use smaller models where possible and cache results.

• Security – Validate and sanitize user input to avoid prompt injection.

• Observability – Log requests and responses for debugging.

• Deploy with Edge Functions – LangChain works well in serverless contexts like Vercel and Cloudflare Workers.

Conclusion

LangChain is a powerful framework that helps JavaScript developers move beyond simple LLM calls to build scalable, production-ready AI applications. Whether you’re creating a chatbot, knowledge retrieval system, or autonomous agent, LangChain provides the abstractions and integrations you need.

With LangChain, JavaScript developers can transform LLMs from simple text generators into intelligent, multi-functional applications.

Next steps:

• Explore LangChain.js docs

• Experiment with different chains and memory modules

• Try integrating with vector databases like Pinecone or Weaviate

• Build your own agent with custom tools