Basics of Developing LLM Applications with LangChain

LangChain Ecosystem Overview

LangChain is a powerful framework that simplifies the process of building applications powered by large language models (LLMs). Whether you’re using proprietary models like OpenAI or open-source alternatives like Hugging Face Transformers, LangChain provides a modular ecosystem to orchestrate prompts, chains, memory, agents, and tools, all under one roof.

In this post, I’ll walk you through the key components of LangChain and how they come together to build flexible, LLM-enabled applications.

LangChain is composed of several libraries:

• LangChain Core: The backbone of the system, managing chains, agents, memory, and prompts.
• LangGraph: Helps design complex agent workflows as graphs.
• LangSmith: Provides debugging, tracing, and observability for LangChain-based applications.

Using LLMs with LangChain

from langchain_community.llms import HuggingFacePipeline

llm = HuggingFacePipeline(pipeline=generator)

LangChain standardizes execution using the .invoke() method, making it easy to switch between models.

Prompt Engineering with LangChain

LangChain makes it easy to structure prompts:

• PromptTemplate: Reusable templates with placeholders.
• ChatPromptTemplate: Enables role-based prompting (system/human/AI).
• FewShotPromptTemplate: Injects examples into prompts for few-shot learning.

PromptTemplate.from_template("Explain {concept}")
ChatPromptTemplate.from_messages([
  ("system", "You are a calculator"),
  ("human", "{math}")
])

Chains

Chains let you pass inputs through multiple components. You can pipe them using |:

chain = prompt_template | model
output = chain.invoke({"concept": "gravity"})

Agents

Agents make decisions using LLMs and external tools. They support frameworks like ReAct (reasoning + action).

Tools can be defined like this:

from langchain.agents import tool

@tool
def generate_report(company_name, revenue, expenses):
    ...

Retrieval Augmented Generation (RAG)

RAG improves LLM outputs by injecting relevant external knowledge at runtime. The workflow:

Workflow:

1. Load documents (e.g., PDFs using PyPDFLoader)
2. Split documents into chunks (e.g., with CharacterTextSplitter)
3. Embed chunks using models (e.g., OpenAIEmbeddings)
4. Store embeddings in vector DBs (e.g., ChromaDB)
5. Retrieve relevant chunks at runtime to augment the prompt

db = Chroma.from_documents(docs, embedding_function, persist_directory="./db")
retriever = db.as_retriever(search_type="similarity", k=2)

Advanced Document Splitting

Choosing the right splitter is key to RAG performance:

• CharacterTextSplitter: Splits text using a fixed character separator.
• RecursiveCharacterTextSplitter: Uses a hierarchy of separators to preserve structure.
• Chunk overlap: Ensures contextual continuity across chunks.

Putting RAG Together

LangChain’s LangChain Expression Language (LCEL) makes chaining easy.

A basic RAG pipeline might look like:

retriever | prompt_template | llm

Custom Tools for Agents

Custom tools allow your agents to interact with real-world systems:

• Perform API calls
• Query databases
• Execute business logic

Use @tool decorator to wrap any function and make it agent-compatible.

Key Takeaways