LangChain Cheatsheet

Complete guide to building AI applications with LangChain. Learn about chains, memory, document processing, and agents with practical examples.

Getting Started with LangChain

Basic Setup

Install and set up LangChain with OpenAI integration

npm install langchain @langchain/openai
          
// Initialize LangChain with OpenAI
import { OpenAI } from "@langchain/openai";

const model = new OpenAI({
  openAIApiKey: "your-api-key",
  temperature: 0.7
});

Simple Chat Completion

Create a basic chat completion using LangChain

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

const chat = new ChatOpenAI();
const response = await chat.invoke([
  new HumanMessage("What is LangChain?")
]);

console.log(response.content);

Chains & Prompts

Creating Simple Chains

Build basic chains to process inputs and generate responses

import { LLMChain } from "langchain/chains";
import { PromptTemplate } from "langchain/prompts";

const prompt = PromptTemplate.fromTemplate(
  "What is the capital of {country}?"
);

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

const result = await chain.invoke({
  country: "France"
});

Sequential Chains

Chain multiple operations together for complex tasks

import { SimpleSequentialChain } from "langchain/chains";

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

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

const overallChain = new SimpleSequentialChain({
  chains: [translateChain, summarizeChain]
});

const result = await overallChain.run(inputText);

Memory & Context

Adding Memory to Chains

Implement conversation memory to maintain context

import { ConversationChain } from "langchain/chains";
import { BufferMemory } from "langchain/memory";

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

// First interaction
await chain.invoke({ input: "Hi! My name is Alice." });

// Second interaction (remembers context)
await chain.invoke({ 
  input: "What's my name?" 
});

Custom Memory

Create custom memory storage for specific needs

import { ChatMessageHistory } from "langchain/memory";

const history = new ChatMessageHistory();

// Add messages
await history.addUserMessage("Hello!");
await history.addAIMessage("Hi there!");

// Get messages
const messages = await history.getMessages();

// Clear memory
await history.clear();

Document Loading & Processing

Loading Documents

Load and process different types of documents

import { TextLoader } from "langchain/document_loaders/fs/text";
import { PDFLoader } from "langchain/document_loaders/fs/pdf";

// Load text file
const textLoader = new TextLoader("path/to/file.txt");
const textDocs = await textLoader.load();

// Load PDF file
const pdfLoader = new PDFLoader("path/to/file.pdf");
const pdfDocs = await pdfLoader.load();

Text Splitting

Split documents into manageable chunks

import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";

const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200
});

const docs = await splitter.splitDocuments(documents);

Vector Stores & Embeddings

Creating Embeddings

Generate and store embeddings for document retrieval

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

const embeddings = new OpenAIEmbeddings();
const vectorStore = await MemoryVectorStore.fromDocuments(
  documents,
  embeddings
);

// Search similar documents
const results = await vectorStore.similaritySearch(
  "query text",
  4  // number of results
);

Question Answering

Create a QA system with document retrieval

import { RetrievalQAChain } from "langchain/chains";

const chain = RetrievalQAChain.fromLLM(
  model,
  vectorStore.asRetriever()
);

const response = await chain.invoke({
  query: "What does the document say about X?"
});

Agents & Tools

Creating Custom Tools

Define tools for agents to use in problem-solving

import { Tool } from "langchain/tools";

const calculator = new Tool({
  name: "Calculator",
  description: "Useful for math calculations",
  func: async (input) => {
    return eval(input).toString();
  }
});

const tools = [calculator];

Agent Setup

Create an agent that can use tools to solve tasks

import { initializeAgentExecutorWithOptions } from "langchain/agents";

const executor = await initializeAgentExecutorWithOptions(
  tools,
  model,
  {
    agentType: "zero-shot-react-description",
    verbose: true
  }
);

const result = await executor.invoke({
  input: "What is 2 + 2?"
});