AI-Framework-Langchain

Overview

LangChain is an open-source framework for building applications powered by Large Language Models (LLMs) such as OpenAI models, Anthropic models, or open-source models via Hugging Face.

It provides abstractions, components, and orchestration tools to build:

• Chatbots
• Retrieval-Augmented Generation (RAG) systems
• Autonomous agents
• Document question-answering systems
• AI workflows

Instead of manually wiring together prompts, APIs, memory, vector databases, and tools, LangChain provides a structured framework to connect them together.

Why LangChain exists

When building an LLM application, you typically need to combine several components. LangChain standardizes and orchestrates them.

Architecture

LangChain is built around several key building blocks:

User Input
      ↓
Prompt Template
      ↓
LLM
      ↓
Chains
      ↓
Tools / Agents
      ↓
External Data (Vector DB / APIs)
      ↓
Response

Core modules:

1. Models
2. Prompts
3. Chains
4. Memory
5. Retrievers
6. Agents
7. Tools
8. Vector Stores

Installing LangChain

pip install langchain
pip install langchain-openai
pip install chromadb
pip install tiktoken

Example environment variable:

export OPENAI_API_KEY="your-api-key"

Using an LLM

The simplest usage is calling an LLM:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini")

response = llm.invoke("Explain quantum computing in simple terms")

print(response.content)

What happens internally:

Prompt → LLM → Response

Prompt templates

Prompts are structured using PromptTemplate:

from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

prompt = PromptTemplate(
    input_variables=["topic"],
    template="Explain {topic} in simple terms for beginners."
)

llm = ChatOpenAI(model="gpt-4o-mini")

formatted_prompt = prompt.format(topic="blockchain")

response = llm.invoke(formatted_prompt)

print(response.content)

Why this matters:

• Reusable prompts
• Parameterized prompts
• Structured LLM interactions

Chains

A Chain connects multiple components:

Input → Prompt → LLM → Output

Example: LLMChain

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

prompt = PromptTemplate(
    input_variables=["product"],
    template="Write a marketing tagline for {product}"
)

llm = ChatOpenAI(model="gpt-4o-mini")

chain = LLMChain(llm=llm, prompt=prompt)

result = chain.invoke({"product": "AI powered coding assistant"})

print(result["text"])

Sequential chains

You can chain multiple steps:

Topic → Generate Outline → Expand Outline → Final Article

from langchain.chains import SimpleSequentialChain
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini")

outline_prompt = PromptTemplate(
    input_variables=["topic"],
    template="Create a blog outline about {topic}"
)

article_prompt = PromptTemplate(
    input_variables=["outline"],
    template="Write a detailed article using this outline:\n{outline}"
)

outline_chain = LLMChain(llm=llm, prompt=outline_prompt)
article_chain = LLMChain(llm=llm, prompt=article_prompt)

chain = SimpleSequentialChain(
    chains=[outline_chain, article_chain]
)

result = chain.invoke("AI agents")

print(result)

Memory (conversation memory)

LLMs normally forget previous interactions. LangChain provides memory systems.

Example: ConversationBufferMemory

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini")

memory = ConversationBufferMemory()

conversation = ConversationChain(
    llm=llm,
    memory=memory
)

conversation.invoke("Hi, my name is Rudresh")
conversation.invoke("What is my name?")

Example output:

Your name is Rudresh.

RAG (retrieval-augmented generation)

Retrieval-Augmented Generation allows LLMs to answer questions using external knowledge by retrieving relevant documents and adding them to the model context.

Document loading

from langchain.document_loaders import TextLoader

loader = TextLoader("data.txt")

documents = loader.load()

Text splitting

from langchain.text_splitter import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)

chunks = text_splitter.split_documents(documents)

Embeddings

from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()

vector = embeddings.embed_query("What is AI?")

Vector databases

Vectors are stored in vector databases such as Pinecone, Weaviate, or Chroma.

from langchain.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=OpenAIEmbeddings()
)

Retrieval

retriever = vectorstore.as_retriever()

docs = retriever.invoke("What is LangChain?")

print(docs[0].page_content)

Building a RAG pipeline

from langchain.chains import RetrievalQA
from langchain_openai import ChatOpenAI

qa_chain = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(model="gpt-4o-mini"),
    retriever=retriever
)

result = qa_chain.invoke(
    {"query": "Explain LangChain architecture"}
)

print(result["result"])

Tools

Tools allow LLMs to call external functions (calculator, web search, APIs, databases, etc.).

from langchain.tools import tool

@tool
def multiply(a: int, b: int) -> int:
    return a * b

Agents

Agents decide which tools to use, when to call tools, and how to combine results.

from langchain.agents import initialize_agent
from langchain.agents import AgentType
from langchain.tools import Tool

tools = [
    Tool(
        name="Calculator",
        func=lambda x: eval(x),
        description="Useful for math calculations"
    )
]

agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

agent.invoke("What is 23 * 45?")

LangChain Expression Language (LCEL)

Modern LangChain uses LCEL for composing pipelines:

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

prompt = ChatPromptTemplate.from_template(
    "Explain {topic} in simple terms"
)

chain = prompt | ChatOpenAI()

result = chain.invoke({"topic": "neural networks"})

Pipeline style:

Prompt | LLM | Parser

Production architecture

Typical production LangChain application architecture:

Frontend (React / Next.js)
          ↓
Backend API (FastAPI)
          ↓
LangChain Pipeline
          ↓
Vector DB (Pinecone / Chroma)
          ↓
LLM Provider (OpenAI / Anthropic)
          ↓
External Tools

Advantages and limitations

Advantages

• Modular architecture
• Large ecosystem
• Integrates with many tools
• Easy RAG pipelines
• Supports agents
• Production-friendly

Limitations

• Abstraction complexity
• Frequent API changes
• Debugging chains can be difficult
• Sometimes slower than raw API usage

LangChain vs LangGraph

LangChain introduced LangGraph for complex agent workflows.

LangGraph is often used for multi-step AI agents.

Real-world use cases

Companies use LangChain for:

• AI copilots
• Document Q&A
• Knowledge assistants
• Automated research
• AI coding assistants
• Customer support bots

In summary

LangChain is a framework for orchestrating LLM applications. It provides structured components such as prompts, chains, memory, tools, agents, vector retrieval, and RAG pipelines, which simplifies building production-grade AI systems.