STEM Robotics Workshops for Kids in Gdansk

Chapter 171 — LangChain Explained for Beginners: Build Apps Powered by Language Models

1. Introduction: What is LangChain & Why Do We Need It?

Large Language Models (LLMs) such as GPT-4, Claude, and Gemini are exceptionally capable at generating text, summarizing articles, and answering general knowledge questions. However, building real-world, production-ready artificial intelligence applications requires more than just making isolated calls to a raw language model.

LangChain is an open-source development framework designed specifically to help developers build, orchestrate, and deploy applications powered by language models.

  ┌─────────────────────────────────────────────────────────────┐
  │                 Raw LLM vs. LangChain Framework             │
  ├───────────────────────────────┬─────────────────────────────┤
  │ Standalone Raw LLM            │ LangChain Application       │
  ├───────────────────────────────┼─────────────────────────────┤
  │ • Stateless single prompt &   │ • Chains multiple LLM calls │
  │   response interactions.      │   into logical pipelines.   │
  │ • Isolated from external live │ • Connects seamlessly to    │
  │   company data sources.       │   external databases & APIs.│
  │ • Retains no built-in chat    │ • Retains conversation      │
  │   memory across sessions.     │   history using memory.     │
  └───────────────────────────────┴─────────────────────────────┘
    

Core Purpose of LangChain:

• Chaining Architecture: LangChain organizes the required components of an AI application into a unified "chain" architecture.
• Simplifying External Interactions: It bridges the gap and simplifies interactions between core LLM models and external data sources, such as databases, APIs, documents, files, and chat logs.
• Pipeline Orchestration: Its foundational idea is to thread together multiple LLM calls, prompts, tools, and memory into a cohesive, logical execution pipeline.

2. Core Architectural Pillars: Modularity, Composability, and Integration

The design philosophy of the LangChain framework rests upon three central architectural pillars:

  ┌─────────────────────────────────────────────────────────────┐
  │              3 Architectural Pillars of LangChain           │
  ├─────────────────────────────────────────────────────────────┤
  │                                                             │
  │   1. Modularity                                             │
  │      • Every module is independently swappable.             │
  │                                                             │
  │   2. Composability                                          │
  │      • Connects distinct modules into logical chains.       │
  │                                                             │
  │   3. Integration                                            │
  │      • Connects LLMs easily to enterprise systems.          │
  │                                                             │
  └─────────────────────────────────────────────────────────────┘
    

1. Modularity: Every operational component in LangChain (such as prompts, models, memory, and tools) is treated as an independent, modular building block. Developers can swap out any specific module—such as changing the underlying LLM from GPT to Gemini—without breaking the rest of the application.
2. Composability: LangChain allows developers to combine and compose these diverse modular building blocks into custom, multi-step chains tailored to specific application requirements.
3. Integration: LangChain provides standardized interfaces that allow LLMs to easily integrate into software applications and connect with external data formats, including third-party APIs, enterprise file stores, and relational or vector databases.

3. The 5 Core Modules of LangChain

LangChain provides five primary core modules that serve as the foundational building blocks for AI application development:

  ┌─────────────────────────────────────────────────────────────┐
  │                 5 Core Modules of LangChain                 │
  ├─────────────────────────────────────────────────────────────┤
  │  1. Models  ──► Standardized interface to LLMs              │
  │  2. Prompts ──► Structures dynamic input text               │
  │  3. Chains  ──► Sequences steps into a unified pipeline     │
  │  4. Agents  ──► Chooses tools & actions dynamically         │
  │  5. Memory  ──► Preserves conversation context              │
  └─────────────────────────────────────────────────────────────┘
    

Module 1: Models (Model I/O)

The Model component provides a clean, unified interface to interact with a wide variety of favorite language models, including OpenAI's GPT, Anthropic's Claude, and Google's Gemini. Instead of writing custom API integration code for each provider, LangChain provides a standardized wrapper.

• Example Use Case: Allows testing multiple LLM providers during development to identify which model offers the best accuracy and performance for a given task.

# Conceptual Example: Initializing an LLM Model in LangChain
from langchain_openai import ChatOpenAI

# Unified interface wrapping the model provider
model = ChatOpenAI(model_name="gpt-4o", temperature=0.7)
response = model.invoke("Explain LangChain in one sentence.")
    

Module 2: Prompts (Prompt Templates)

Prompts define and structure the input text sent to the LLM. In production apps, inputs cannot be static strings; they must dynamically insert user variables into structured templates.

• Example Use Case: Creating a re-usable translation or summarization template where user inputs are inserted dynamically into predefined instruction roles.

# Conceptual Example: Defining a PromptTemplate in LangChain
from langchain_core.prompts import PromptTemplate

# Define template structure with input variables
template = PromptTemplate.from_template(
    "You are an expert AI tutor. Explain {topic} to a {target_audience} in simple terms."
)

# Populate input variables dynamically
formatted_prompt = template.format(topic="LangChain", target_audience="beginner")
    

Module 3: Chains

Chains connect input variables, prompt templates, models, and output parsers into a continuous, sequential pipeline. In a chain, the output of one operation can automatically feed into the input of the next operation.

• Example Use Case: Taking raw user input, formatting it via a Prompt Template, passing it to an LLM Model, and parsing the response in a single execution line.

# Conceptual Example: Combining Prompt and Model into a Chain
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

prompt = PromptTemplate.from_template("Summarize the key benefits of {technology}.")
model = ChatOpenAI(model_name="gpt-4o")

# Connect components into a chain using the pipe (|) operator
chain = prompt | model
result = chain.invoke({"technology": "LangChain"})
    

Module 4: Agents

While a standard Chain executes a fixed, hardcoded sequence of steps, an Agent uses the LLM as a reasoning engine to dynamically decide which actions to take and which tools to use to satisfy a user request.

• Tools and APIs: Agents can access external tools such as web search engines, mathematical calculators, custom code execution sandboxes, or database query tools.
• Dynamic Decision Making: The agent evaluates the user query, determines if external tools are required, executes those tools, and synthesizes the final output.

# Conceptual Architecture: How an Agent selects tools
# User Request: "What is the stock price of Apple multiplied by 3?"
# Agent Decision Loop:
#   1. Call Search Tool -> Fetch live Apple stock price ($230)
#   2. Call Calculator Tool -> Compute 230 * 3 = 690
#   3. Return Final Answer -> "Three times Apple's current stock price is $690."
    

Module 5: Memory

By default, LLM API calls are completely stateless—they do not remember previous messages. The Memory module persists context and conversation history across successive interactions between the user and the system.

• Context Retention: Memory maintains past dialogue so the user receives answers that are relevant to prior context.
• Enhanced User Experience: Expanding the available memory infrastructure allows the model to handle larger context windows, giving users a seamless conversational experience.

# Conceptual Example: Adding Memory to retain conversation context
from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
memory.save_context({"input": "Hi, my name is Alex."}, {"output": "Hello Alex! How can I help you today?"})

# Retrieve stored dialogue history for subsequent LLM calls
history = memory.load_memory_variables({})
    

4. External Data Sources & Orchestration

LangChain excels at connecting language models to external data stores to build Retrieval-Augmented Generation (RAG) pipelines and enterprise search chatbots.

  ┌─────────────────────────────────────────────────────────────┐
  │               LangChain Data Orchestration Pipeline         │
  ├─────────────────────────────────────────────────────────────┤
  │  External Data Sources (Files, PDFs, APIs, Databases)       │
  │                             │                               │
  │                             ▼                               │
  │  Document Loaders & Text Splitters                          │
  │                             │                               │
  │                             ▼                               │
  │  Vector Stores & Similarity Indexing                        │
  │                             │                               │
  │                             ▼                               │
  │  LLM Query Processing + Context-Aware Generation            │
  └─────────────────────────────────────────────────────────────┘
    

LangChain orchestrates this flow by ingesting external files, converting document text into numerical vector embeddings, storing them in similarity indexes, and retrieving matching context blocks whenever a user asks a question.

5. Summary Matrix of LangChain Core Modules

Core Module	Primary Function	Operational Role in Pipeline	Practical Benefit
Models	Provider interface.	Connects to GPT, Claude, or Gemini.	Standardizes multi-LLM integration.
Prompts	Input structuring.	Defines dynamic prompt templates.	Eliminates hardcoded text strings.
Chains	Sequential pipeline.	Links inputs, prompts, and models.	Automates multi-step workflows.
Agents	Dynamic reasoning engine.	Selects tools and APIs autonomously.	Handles complex, unpredictable tasks.
Memory	State & history management.	Stores chat logs and interaction context.	Provides context-aware answers.