HazelJS vs LangChain

TL;DR

• LangChain is an AI orchestration library — chains, tools, retrievers, and a huge integration ecosystem (Python & JS).
• HazelJS is a full TypeScript backend framework with AI built in: HTTP, DI, agents, RAG, memory, and workflows in one module system.
• Use LangChain when you need its ecosystem breadth or you already own the HTTP layer.
• Use HazelJS when you want one codebase for APIs + agents + RAG without Nest/Express glue.

Who this is for

Read this if you:

• Are choosing between LangChain.js and a TypeScript AI backend framework
• Already glue LangChain into Express/Nest and want less wiring
• Need production agents with auth, caching, and observability in the same app

Stay on LangChain if you:

• Are Python-first or depend on LangChain Hub / niche integrations HazelJS does not ship
• Only need research notebooks or scripts — not a long-lived API service
• Standardized on LangSmith and do not want another observability story yet

What LangChain solves (and does not)

LangChain excels at composing LLM pipelines: prompts, retrievers, tools, and agents. Production still means you supply:

• An HTTP server (Express, Nest, Fastify, …)
• Auth, rate limits, multi-tenant config
• Deployment, health checks, resilience
• How tool calls inherit user identity from the request

HazelJS treats those as first-class: controllers and agents share the same DI container.

Side-by-side

Code: library vs framework

LangChain-style chain (you still need a server around it):

import { ChatOpenAI } from '@langchain/openai';
import { ConcurrentRunnableSequence } from '@langchain/core/runnables';

const model = new ChatOpenAI({ model: 'gpt-4o' });
// Wire retriever, prompt, tools… then mount inside Express/Nest yourself

HazelJS — AI inside the same module as HTTP:

import { Injectable, Controller, Post, Body, HazelModule } from '@hazeljs/core';
import { AIService } from '@hazeljs/ai';

@Injectable()
class AssistService {
  constructor(private ai: AIService) {}

  ask(input: string) {
    return this.ai.hazel
      .prompt('Answer with docs: {{input}}')
      .rag('kb')
      .execute(input);
  }
}

@Controller({ path: '/assist' })
class AssistController {
  constructor(private assist: AssistService) {}

  @Post()
  run(@Body() body: { q: string }) {
    return this.assist.ask(body.q);
  }
}

@HazelModule({
  controllers: [AssistController],
  providers: [AssistService],
})
export class AppModule {}

Decorator agent (no separate executor package):

import { Agent, Tool } from '@hazeljs/agent';

@Agent({
  name: 'researcher',
  systemPrompt: 'Research and cite sources.',
  enableRAG: true,
})
export class ResearchAgent {
  @Tool({
    description: 'Search the knowledge base',
    parameters: [{ name: 'query', type: 'string', required: true }],
  })
  async search(input: { query: string }) {
    return { hits: [] };
  }
}

Decision guide

When LangChain is the better choice

• Ecosystem plugins and community examples matter more than a unified backend
• You already invested in LangSmith traces and org playbooks
• The “app” is a script, notebook, or worker — not a Nest-style service

HazelJS wins when shipping an AI product backend (auth’d APIs, agents, RAG, ops) in TypeScript is the job.

Related

• NestJS + LangChain vs HazelJS
• HazelJS vs LangGraph
• HazelJS vs NestJS
• HCEL guide · Agent package · RAG

Next steps

1. Installation
2. AI package docs
3. RAG vs Agentic RAG
4. GitHub