LangChain શું છે? LLM એપ્લિકેશન્સ બનાવવા માટેનું ફ્રેમવર્ક — PDF Q&A, Memory Chatbot, Agents

LangChain શું છે? LLM એપ્લિકેશન્સ બનાવવા માટેનું ફ્રેમવર્ક — સરળ ગુજરાતીમાં

આપણે OpenAI API વિશે શીખ્યા — અને ChatGPT ને કોલ (Call) કરતા પણ શીખ્યા. પણ હવે આગળ શું?

જો તમારે એક રિયલ AI એપ્લિકેશન (Real AI App) બનાવવી હોય, જેમ કે:

કોઈ PDF અપલોડ કરીને AI પાસે તેની સમરી (Summary) બનાવડાવવી.
તમારી કંપનીના પ્રાઇવેટ ડેટામાં AI ની મદદથી સર્ચ (Search) કરવું.
એક એવો રિસર્ચ એજન્ટ (Research Agent) બનાવવો જે અલગ-અલગ વાતો સમજીને જાતે કામ કરે.
એવો ચેટબોટ (Chatbot) બનાવવો જેને તમારી જૂની વાતો યાદ રહે (Memory).

જો આ બધું માત્ર OpenAI API ની મદદથી જાતે કરવા જઇએ તો, ખૂબ જ મોટો કોડ લખવો પડે અને તે અત્યંત જટિલ (Complex) બની જાય. બરાબર અહીં જ LangChain કામ આવે છે. LangChain = AI Apps બનાવવા માટેનું એક રેડીમેડ ફ્રેમવર્ક (Ready Framework) — જેમાં બેકગ્રાઉન્ડ સેટઅપ અને વાયરિંગની મહેનત ઓછી છે અને એપ બનાવવા (Building) પર વધુ ધ્યાન આપી શકાય છે.

LangChain એટલે શું?

LangChain = LLM-Powered એપ્લિકેશન્સ બનાવવા માટેનું Python અને JavaScript મા લખાયેલું એક ફ્રેમવર્ક છે.

💡 સરળ ઉદાહરણ — LEGO બ્લોક્સ:

OpenAI API = પ્લાસ્ટિક (કાચો માલ - Raw Material)

LangChain = ફિટ કરવા માટે તૈયાર LEGO બ્લોક્સ (Ready Pieces)

AI App = LEGO નો બનેલો મહેલ (Final Product)

કાચા માલમાંથી સીધો મહેલ બનાવવો ખૂબ અઘરો છે — પરંતુ તૈયાર LEGO બ્લોક્સથી તે ઝડપથી અને સરળતાથી બની શકે છે!

LangChain ના તૈયાર કમ્પોનન્ટ્સ (Ready Components):

LLM Connection: (OpenAI, Gemini, Llama, Hugging Face સાથે જોડાણ)
Prompt Templates: (પ્રોમ્પ્ટના તૈયાર ઢાંચા)
Memory: (વાતચીતનો ઇતિહાસ યાદ રાખવાની સુવિધા)
Document Loaders: (PDF, Web, CSV ફાઇલો વાંચવા માટે)
Vector Stores: (અર્થપૂર્ણ સર્ચ એટલે કે Semantic Search માટે)
Chains: (અલગ-અલગ સ્ટેપ્સને એકબીજા સાથે જોડવા માટે)
Agents: (જે જાતે નિર્ણયો લઈ શકે અને ટાસ્ક સિદ્ધ કરી શકે)

ઇન્સ્ટોલેશન (Installation)

pip install langchain langchain-openai langchain-community
pip install python-dotenv faiss-cpu

1. ઍક બેઝિક LLM કોલ (Basic LLM Call)

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage

# LLM સેટઅપ
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)

# મેસેજિસ 
messages = [
    SystemMessage(content="તમે ગુજરાતી AI આસિસ્ટન્ટ છો."),
    HumanMessage(content="AI ના ફાયદા માત્ર 3 પોઇન્ટ્સમાં જણાવો.")
]

# કોલ 
response = llm.invoke(messages)
print(response.content)

2. પ્રોમ્પ્ટ ટેમ્પ્લેટ્સ (Prompt Templates) — વારંવાર ઉપયોગમાં લઈ શકાય તેવા પ્રોમ્પ્ટ્સ

from langchain_core.prompts import ChatPromptTemplate

# ટેમ્પ્લેટ વ્યાખ્યાયિત કરો (Define Template)
template = ChatPromptTemplate.from_messages([
    ("system", "તમે {language} ભાષાના નિષ્ણાત (Expert) છો."),
    ("human", "{topic} ને માત્ર 3 પોઇન્ટ્સમાં સમજાવો.")
])

# અલગ-અલગ ઇનપુટ્સ સાથે ટેમ્પ્લેટનો ફરી ઉપયોગ
prompt = template.invoke({
    "language": "ગુજરાતી",
    "topic": "Machine Learning"
})

response = llm.invoke(prompt)
print(response.content)

3. ચેઇન (Chain) — સ્ટેપ્સને કનેક્ટ કરવા

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# સિમ્પલ ચેઇન: Prompt → LLM → Output
prompt = ChatPromptTemplate.from_template(
    "{topic} ઉપર એક ટૂંકી ગુજરાતી બ્લોગ પોસ્ટ લખો."
)

chain = prompt | llm | StrOutputParser()

result = chain.invoke({"topic": "Artificial Intelligence"})
print(result)

| ઓપરેટર = LangChain પાઇપ (Pipe) — આ વ્યવસ્થા અલગ-અલગ સ્ટેપ્સને ભેગા કરે છે. તેથી કોડ સમજવામાં એકદમ સરળ (Simple) છે.

4. મેમરી (Memory) — ચેટમાં જૂની વાતો યાદ રાખવી

from langchain_openai import ChatOpenAI
from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

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

# મેમરી સાથેનો પ્રોમ્પ્ટ 
prompt = ChatPromptTemplate.from_messages([
    ("system", "તમે એક મદદરૂપ (Helpful) આસિસ્ટન્ટ છો."),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])

chain = prompt | llm | StrOutputParser()

# મેમરી સ્ટોર કરવા માટે
store = {}

def get_session_history(session_id):
    if session_id not in store:
        store[session_id] = InMemoryChatMessageHistory()
    return store[session_id]

# મેમરી ધરાવતી ચેઇન 
chain_with_memory = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history"
)

# ચેટબોટ — મેમરી ઓટોમેટિક કામ કરશે
config = {"configurable": {"session_id": "user_1"}}

r1 = chain_with_memory.invoke({"input": "મારું નામ રાજ (Raj) છે."}, config=config)
print(r1)   # "હેલો રાજ! શું મદદ કરું?"

r2 = chain_with_memory.invoke({"input": "મારું નામ શું છે?"}, config=config)
print(r2)   # "તમારું નામ રાજ છે." ← મેમરી!

5. ડોક્યુમેન્ટ લોડર (Document Loader) — PDF/Text ફાઇલો વાંચવી

from langchain_community.document_loaders import PyPDFLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

# PDF લોડ કરો
loader = PyPDFLoader("document.pdf")
pages = loader.load()
print(f"કુલ પેજીસ: {len(pages)}")

# મોટા ડોક્યુમેન્ટના નાના ટુકડા કરવા (Chunks)
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,      # એક ટુકડામાં 1000 અક્ષરો (Characters per Chunk)
    chunk_overlap=200     # અગાઉના ટુકડાના 200 અક્ષરો કવર કરવા (જેથી વાક્ય તૂટે નહિ)
)
chunks = splitter.split_documents(pages)
print(f"કુલ ટુકડા (Chunks): {len(chunks)}")

6. RAG — ડોક્યુમેન્ટ પરથી જવાબો આપવા (Q&A)

RAG = Retrieval-Augmented Generation — કંપનીનું ડોક્યુમેન્ટ અપલોડ કરો → સવાલ પૂછો → AI ડોક્યુમેન્ટમાંથી જવાબ શોધીને આપશે.

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

# 1. ડોક્યુમેન્ટ લોડ કરો અને તેના ટુકડા કરો (Split)
loader = PyPDFLoader("company_policy.pdf")
docs = loader.load()

splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(docs)

# 2. Embeddings અને Vector Store બનાવો
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

# 3. Retriever (માહિતી શોધવા માટે) તૈયાર કરો
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# 4. QA ચેઇન (QA Chain) બનાવો
llm = ChatOpenAI(model="gpt-4o-mini")
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=retriever
)

# 5. સવાલ પૂછો!
answer = qa_chain.invoke("રજાના નિયમો (Leave Policy) શું છે?")
print(answer['result'])

💡 રિયલ યુઝ (Real Use): કંપનીની PDF પરથી કર્મચારીઓ માટે Q&A બોટ બનાવવો, કાનૂની દસ્તાવેજો સર્ચ કરવા, અથવા કોઈ પુસ્તકની સમરી લેવી.

7. એજન્ટ (Agent) — ઓટોમેટિક ટાસ્ક સિદ્ધ કરવા

એજન્ટ = LLM + વિવિધ ટૂલ્સ (Tools) — અહીં AI જાતે નક્કી કરશે કે તેણે કયું ટૂલ વાપરવું છે અને જાતે જ એક્સન લેશે.

from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_core.tools import tool

# આપણું પોતાનું ઍક કસ્ટમ ટૂલ (Custom Tool)
@tool
def calculator(expression: str) -> str:
    """Mathematical expression પોતે ગણતરી (calculate) કરે છે. ઉદાહરણ: '2 + 2'"""
    return str(eval(expression))

# વેબ સર્ચ ટૂલ (Web Search Tool)
search = DuckDuckGoSearchRun()
tools = [calculator, search]

# એજન્ટ સેટઅપ (Agent Setup)
llm = ChatOpenAI(model="gpt-4o-mini")
prompt = ChatPromptTemplate.from_messages([
    ("system", "તમે એક મદદરૂપ આસિસ્ટન્ટ છો અને તમારી પાસે કેટલાક ટુલ્સ છે."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}")
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# કોલ — AI જાતે નક્કી કરશે કે તેને કેલ્ક્યુલેટર વાપરવું છે કે વેબ સર્ચ કરવું છે?
result = executor.invoke({"input": "345 × 678 શું થાય?"})
print(result['output'])
# અહીં AI જાતે > calculator("345 * 678") રન કરશે અને → 233910 જવાબ લાવશે.

LangChain ના ઘટકોની ઝલક (Components Overview)

કમ્પોનન્ટ (Component)	કામ (Work)	ઉદાહરણ (Examples)
LLMs	AI મોડલનું કનેક્શન આપે છે	ChatOpenAI, Gemini
Prompt Templates	તૈયાર ઢાંચા	બ્લોગ, ઈમેલ માટેના ટેમ્પ્લેટ્સ
Chains	સ્ટેપ્સ જોડવા માટે	Prompt → LLM → Output
Memory	ચેટ હિસ્ટ્રી	જૂનો સંદર્ભ (Context) યાદ રાખવા
Document Loaders	ડેટા લેવા માટે	PDF, CSV, વેબ પેજીસ
Vector Stores	અર્થપૂર્ણ સર્ચ માટે	FAISS, Pinecone
Retrievers	કામના ટુકડા શોધવા	RAG સિસ્ટમ માટે
Agents	સમજદારીપૂર્વકના એક્શન લેવા	રિસર્ચ, કેલ્ક્યુલેટર વાપરવું
Tools	બહારના ટાસ્ક કરવા	ઈન્ટરનેટ સર્ચ, API, ડેટાબેઝ

LangChain વર્સિસ ડાયરેક્ટ API (LangChain vs Direct API)

	ડાયરેક્ટ OpenAI API	LangChain
સેટઅપ (Setup)	ખૂબ સરળ (Simple) છે	મધ્યમ (Moderate) છે
સામાન્ય ચેટબોટ	✅ ડાયરેક્ટ API વધુ સારું	❌ થોડું વધારે કોમ્પ્લેક્સ છે (Overkill)
RAG / ડોક્યુમેન્ટ્સ	❌ ઘણો લાંબો કોડ લખવો પડે	✅ એકદમ આસાનીથી થઈ જાય (Easy)
મેમરી (Memory)	પોતે જાતે મેનેજ કરવી પડે	✅ સીધી જ ઉપલબ્ધ છે (Built-in)
Agents	❌ ડિઝાઇન કરવા અઘરા છે	✅ તેનું રેડીમેડ માળખું છે (Ready)
મલ્ટી-મોડલ	❌ એક જ મોડેલ પર ટકેલું	✅ કોઈપણ LLM જોડી શકાય
પ્રોડક્શન એપ્સ	મર્યાદિત (Limited)	✅ કોઈ પણ મોટી એપ બનાવી શકાય

💡 સિમ્પલ ચેટ એપ માટે → ડાયરેક્ટ API વાપરો. પરંતુ જો RAG, એજન્ટ્સ અને જટિલ એપ્સ બનાવવી હોય તો → LangChain વાપરો.

LangChain સાથે ઍક રિયલ-વર્લ્ડ પ્રોજેક્ટ્સનું ઉદાહરણ

🏢 કંપનીનો નોલેજ બોટ (Company Knowledge Bot):

100 PDF ફાઇલો અપલોડ કરી વેક્ટર સ્ટોર બનાવો.
કંપનીનો કોઈ કર્મચારી ડોક્યુમેન્ટ અંગે કોઈ પણ સવાલ પૂછી શકશે, અને બોટ તેમાંથી સાચો જવાબ આપશે.

📧 ઈમેલ આસિસ્ટન્ટ (Email Assistant):

ઇનબોક્સમાં આવેલા મેઈલ વાંચીને, તેને કેટેગરાઇઝ કરી જાતે જ સામેવાળાને રિપ્લાય માટે ડ્રાફ્ટ બનાવવો.

📊 ડેટા એનાલિસ્ટ એજન્ટ (Data Analyst Agent):

મોટી બેલેન્સશીટ જેવી CSV ફાઈલ અપલોડ કરીને સામાન્ય ભાષામાં પ્રશ્ન પૂછો → AI તેમાંથી કોડ ચલાવીને પોતે જવાબ લાવશે.

🔍 રિસર્ચ એજન્ટ (Research Agent):

કોઈ વિષયનું નામ આપો → AI પોતે જ વેબ સર્ચ કરીને, માહિતી એકત્ર કરી સરસ મજાનો રિપોર્ટ જનરેટ કરશે.

નિષ્કર્ષ

LangChain બધી જ આધુનિક AI એપ્લિકેશન્સની કરોડરજ્જુ (Backbone) સમાન છે. સીધા LLM ને કનેક્ટ કરીને પ્રોમ્પ્ટ, મેમરી, ડોક્યુમેન્ટ્સ અને એજન્ટ્સને એકબીજા સાથે જોડવા — એટલે કે હવે ફક્ત વાયરિંગ કરવાનું છે અને નવી વસ્તુઓ બનાવવાની છે.

સિમ્પલ ચેટ             → સીધું OpenAI API વાપરો
PDF ઉપર સવાલો પૂછવા     → LangChain + RAG વાપરો
મેમરીવાળો ચેટબોટ        → LangChain Memory વાપરો
રિસર્ચ કરતો AI એજન્ટ    → LangChain Agents વાપરો

બસ તો તમારા કમાન્ડ પ્રોમ્પ્ટમાં જઈને pip install langchain લખો — અને એડવાન્સ્ડ AI એપ ડેવલપમેન્ટની દુનિયામાં પ્રવેશ કરો! 🚀

WhatsApp Twitter LinkedIn