Introduction to LangChain

Introduction to LangChain

LangChain is the orchestration framework we will use throughout this course to build AI applications. It's the glue between your code and language models.

What is LangChain?

A framework for developing applications powered by language models. Think of it as:

• The "rails" for your AI application
• Orchestration layer between your code and LLMs
• Standard patterns for common AI tasks
• Abstraction that works with any model

Official Documentation (JavaScript) | Python Version | GitHub

Why Jesse Loves LangChain

"From building peake.ai in 1 hour: LangChain automations followed an hour later. It handles the messy parts—prompt management, model switching, chain-of-thought reasoning—so I can focus on the business logic."

Key Benefits:

• Model Agnostic - Swap OpenAI for Claude in one line of code
• Prompt Management - Templates, versioning, testing built-in
• Chain Complex Tasks - Multi-step reasoning flows
• Memory Management - Conversation history and context
• Tool Integration - Connect to APIs, databases, web search
• Production-Ready - Error handling, retries, logging included

Core LangChain Concepts

1. LLMs (Language Models)

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

const model = new ChatOpenAI({ 
  temperature: 0.7,
  modelName: "gpt-4"
});

2. Prompts (Prompt Templates)

import { PromptTemplate } from "langchain/prompts";

const prompt = PromptTemplate.fromTemplate(
  "You are a {role}. {instruction}"
);

const formatted = await prompt.format({
  role: "helpful AI assistant",
  instruction: "Explain Git in simple terms"
});

3. Chains (Sequences of Calls)

const chain = prompt.pipe(model);

const result = await chain.invoke({ 
  role: "technical writer",
  instruction: "Explain what LangChain is"
});

4. Agents (Autonomous Decision Makers)

import { createAgent } from "langchain/agents";

const agent = createAgent({
  tools: [searchTool, calculatorTool],
  llm: model
});

// Agent decides which tools to use
const result = await agent.run("What's the weather in Tokyo?");

5. Memory (Context Retention)

import { BufferMemory } from "langchain/memory";

const memory = new BufferMemory();
// Automatically remembers conversation history

6. Tools (External Capabilities)

Give your AI the ability to:

• Search the web
• Run calculations
• Query databases
• Call APIs
• Read/write files
• Execute code

LangChain vs Raw API Calls

Without LangChain:

// Manual everything
const response = await fetch('https://api.openai.com/v1/chat/completions', {
  method: 'POST',
  headers: { /* ... */ },
  body: JSON.stringify({
    model: "gpt-4",
    messages: [/* manually construct */],
    // Handle model-specific syntax
    // Manage conversation state yourself
    // Write custom retry logic
    // Parse responses manually
  })
});

With LangChain:

const chain = promptTemplate.pipe(model).pipe(outputParser);
const result = await chain.invoke(input);
// LangChain handles everything

Real Example: Cadderly

Jesse's coordination agent uses LangChain for:

• Intent recognition from user commands
• Context management across conversations
• Tool calling (file system, calendar, web search)
• Multi-step workflows (research → summarize → action)
• Response formatting and validation

LangChain Ecosystem

LangChain.js (What We'll Use)

• JavaScript/TypeScript version
• Works with Next.js, React, Node.js
• Install: npm install langchain

LangChain Python

• More mature, larger community
• Great for data science workflows
• Install: pip install langchain

LangSmith (Observability)

smith.langchain.com

• Debug and monitor LangChain applications
• Trace calls and costs
• Evaluate performance over time

LangServe (Deployment)

• Deploy LangChain apps as REST APIs
• Production-ready server

When to Use LangChain

Use LangChain When:

• Building complex AI workflows
• Need to chain multiple LLM steps
• Want model flexibility (easy switching)
• Building agents with tools
• Need conversation memory
• Deploying to production

Skip LangChain When:

• Simple one-off API calls
• Maximum performance is critical (direct API is faster)
• Just learning LLM basics
• Very simple use case (single prompt/response)

Throughout This Course

We will use LangChain extensively in:

• Module 4: RAG implementation with vector stores
• Module 5: Tool calling and function execution
• Module 6: Building agents and chatbots
• Module 7: Multi-agent system coordination
• Module 11: MCP and A2A protocol integration

Installation

# Install LangChain
npm install langchain

# Install model integrations
npm install @langchain/openai
npm install @langchain/anthropic

# Install additional tools
npm install @langchain/community

Your First LangChain Example

Try this simple example (covered in video):

import { ChatOpenAI } from "@langchain/openai";
import { PromptTemplate } from "langchain/prompts";

const model = new ChatOpenAI({ temperature: 0.7 });
const prompt = PromptTemplate.fromTemplate(
  "Tell me a {adjective} fact about {topic}"
);

const chain = prompt.pipe(model);

const result = await chain.invoke({
  adjective: "interesting",
  topic: "AI development"
});

console.log(result.content);

Resources

• LangChain.js Introduction
• LangChain Quickstart
• LangChain.js GitHub
• Platform Integrations
• Download our LangChain Starter Pack in the resources above