chain

Multi-step AI reasoning — prompt templates, output parsing, RAG, and text splitting

Overview

The chain module wraps LangChain.js for multi-step AI reasoning with prompt templates, structured output parsing, retrieval-augmented generation (RAG), and text splitting. Falls back to built-in implementations when LangChain is not installed.

Peer dependencies: @langchain/core, @langchain/textsplitters

npm install @langchain/core @langchain/textsplitters

yarn add @langchain/core @langchain/textsplitters

pnpm add @langchain/core @langchain/textsplitters

Quick Start

import { prompt, parse, createChain } from '@jamaalbuilds/ai-toolkit/chain';
import { z } from 'zod';

const p = prompt({
  template: [
    ['system', 'You extract structured data from text.'],
    ['human', 'Extract info from: {text}'],
  ],
});

const formatted = await p.format({ text: 'John is 30 years old' });

API Reference

prompt(config)

Create a prompt template with variable substitution.

function prompt(config: PromptConfig): PromptTemplate

// Simple string template
const p = prompt({ template: 'Summarize: {text}' });
const result = await p.format({ text: 'Long article...' });

// Chat message template
const p = prompt({
  template: [
    ['system', 'You are a helpful assistant.'],
    ['human', '{question}'],
  ],
});

parse(config)

Create a structured output parser from a Zod schema.

function parse(config: ParseConfig): Parser

const parser = parse({
  schema: z.object({ name: z.string(), age: z.number() }),
});

const instructions = parser.getFormatInstructions(); // for the LLM
const result = await parser.parse('{"name": "John", "age": 30}');

createChain(config)

Compose a multi-step chain from sequential functions.

function createChain(config: ChainConfig): Chain

const chain = createChain({
  name: 'extract',
  steps: [
    async (input) => formatPrompt(input),
    async (prompt) => callLLM(prompt),
    async (output) => parseOutput(output),
  ],
});

const result = await chain.invoke({ text: 'John is 30' });

rag(config)

Create a retrieval-augmented generation chain.

function rag(config: RAGConfig): Chain<{ question: string }, RAGResult>

const ragChain = rag({
  retriever: { retrieve: async (query) => searchDocs(query) },
  promptTemplate: 'Context:\n{context}\n\nQuestion: {question}\n\nAnswer:',
  model: async (prompt) => callLLM(prompt),
});

const result = await ragChain.invoke({ question: 'What is the return policy?' });

createSplitter(config)

Create a text splitter for chunking documents.

function createSplitter(config: SplitterConfig): Splitter

const splitter = createSplitter({ chunkSize: 500, chunkOverlap: 50 });
const chunks = await splitter.split('Very long document text...');

createLanguageSplitter(config)

Create a code-aware splitter that respects language syntax boundaries.

function createLanguageSplitter(language: SplitterLanguage, config?: { chunkSize?: number; chunkOverlap?: number }): Splitter

const splitter = createLanguageSplitter('js', {
  chunkSize: 1000,
  chunkOverlap: 100,
});

Types

• Chain — composable chain with invoke() method
• PromptTemplate — template with format() method
• Parser — parser with parse() and getFormatInstructions()
• Splitter — splitter with split() and splitDocuments() methods
• RAGResult — answer, sources, context
• ChatMessage — { role: 'system' | 'human' | 'ai', content: string }
• SplitterLanguage — 'js' | 'python' | 'go' | 'java' | 'ruby' | 'rust' | 'cpp' | 'php' | 'scala' | 'swift' | 'markdown' | 'latex' | 'html'