LangChain Tutorial (TypeScript): chunking large documents for advanced developers

This tutorial shows you how to split large documents into retrieval-friendly chunks in TypeScript using LangChain, then inspect and tune the output for downstream RAG pipelines. You need this when a single file is too large for embeddings, search quality drops because chunks are poorly sized, or you want deterministic chunking that survives production workloads.

What You'll Need

• •Node.js 18+
• •TypeScript 5+
• •A project initialized with npm init -y
• •These packages:
  • •langchain
  • •@langchain/core
  • •@langchain/textsplitters
  • •typescript
  • •tsx or ts-node for running TypeScript directly
• •A text file to chunk, such as a policy document, contract, manual, or internal wiki export
• •Optional:
  • •OpenAI API key if you plan to embed chunks later
  • •A vector store if this chunking step feeds retrieval

Step-by-Step

1. •Start with a loader that gets your document into LangChain as Document objects. For local files, TextLoader is enough and keeps the example focused on chunking instead of ingestion complexity.

import { TextLoader } from "@langchain/community/document_loaders/fs/text";

async function main() {
  const loader = new TextLoader("./data/large-document.txt");
  const docs = await loader.load();

  console.log(`Loaded ${docs.length} document(s)`);
  console.log(docs[0].pageContent.slice(0, 200));
}

main().catch(console.error);

2. •Use a recursive splitter for general-purpose chunking. This is the default workhorse for large documents because it tries paragraphs first, then sentences, then smaller separators until it hits your size target.

import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
import { TextLoader } from "@langchain/community/document_loaders/fs/text";

async function main() {
  const loader = new TextLoader("./data/large-document.txt");
  const docs = await loader.load();

  const splitter = new RecursiveCharacterTextSplitter({
    chunkSize: 1200,
    chunkOverlap: 150,
    separators: ["\n\n", "\n", ". ", " ", ""],
  });

  const chunks = await splitter.splitDocuments(docs);

  console.log(`Created ${chunks.length} chunks`);
}

main().catch(console.error);

3. •Inspect the chunk metadata before sending anything to embeddings or retrieval. In production, you want traceability back to the source file and chunk index so you can debug bad answers later.

import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
import { TextLoader } from "@langchain/community/document_loaders/fs/text";

async function main() {
  const loader = new TextLoader("./data/large-document.txt");
  const docs = await loader.load();

  const splitter = new RecursiveCharacterTextSplitter({
    chunkSize: 1000,
    chunkOverlap: 100,
    addStartIndex: true,
  });

  const chunks = await splitter.splitDocuments(docs);

  chunks.slice(0, 3).forEach((chunk, i) => {
    console.log(`--- Chunk ${i + 1} ---`);
    console.log(chunk.metadata);
    console.log(chunk.pageContent.slice(0, 300));
  });
}

main().catch(console.error);

4. •Tune the splitter based on document structure instead of guessing. Legal contracts, technical manuals, and policy docs often behave better with custom separators than with the default sentence-first strategy.

import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
import { TextLoader } from "@langchain/community/document_loaders/fs/text";

async function main() {
  const loader = new TextLoader("./data/large-document.txt");
  const docs = await loader.load();

  const splitter = new RecursiveCharacterTextSplitter({
    chunkSize: 800,
    chunkOverlap: 120,
    separators: [
      "\n\n## ",
      "\n\n### ",
      "\n\n",
      "\n",
      ". ",
      " ",
      "",
    ],
    keepSeparator: true,
  });

  const chunks = await splitter.splitDocuments(docs);

  console.log(`Chunks: ${chunks.length}`);
}

main().catch(console.error);

5. •If you need token-aware splitting for LLM-bound workflows, use a tokenizer-based splitter instead of character counts. This is more stable when your model context window matters more than raw text length.

import { TokenTextSplitter } from "@langchain/textsplitters";
import { TextLoader } from "@langchain/community/document_loaders/fs/text";

async function main() {
  const loader = new TextLoader("./data/large-document.txt");
  const docs = await loader.load();

  const splitter = new TokenTextSplitter({
    encodingName: "cl100k_base",
    chunkSize: 300,
    chunkOverlap: 40,
    disallowedSpecialTokens: [],
    allowedSpecialTokens: [],
  });

  const chunks = await splitter.splitDocuments(docs);

  console.log(`Token-based chunks: ${chunks.length}`);
}

main().catch(console.error);

Testing It

Run the script against a real document with headings, long paragraphs, and repeated sections. You should see multiple chunks printed with consistent metadata and no empty outputs.

Check that adjacent chunks overlap enough to preserve context but not so much that you duplicate most of the source text. For retrieval use cases, inspect whether important terms like product names, clause IDs, or section headers appear in the resulting chunks.

If you are preparing data for embeddings, take one or two chunks and compare their length against your model’s practical input limits. If answers feel fragmented later in RAG testing, reduce chunk size slightly or increase overlap around section boundaries.

Next Steps

• •Add embeddings and push these chunks into a vector store like PGVector or Pinecone.
• •Build a retrieval chain that returns source snippets alongside answers.
• •Add document-specific split strategies for PDFs, markdown files, and OCR output separately.

Keep learning

• •The complete AI Agents Roadmap — my full 8-step breakdown
• •Free: The AI Agent Starter Kit — PDF checklist + starter code
• •Work with me — I build AI for banks and insurance companies

By Cyprian Aarons, AI Consultant at Topiax.