# pip install langchain langchain-openai
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
# 1) मॉडेल
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
# 2) प्रॉम्प्ट
prompt = ChatPromptTemplate.from_messages( आणि स्ट्रीमिंग मार्गदर्शक.
---
## बिल्डिंग ब्लॉक्स जे तुम्ही 80% वेळा वापराल
### 1) प्रॉम्प्ट्स आणि आउटपुट पार्सिंग
- स्ट्रक्चर्ड प्रॉम्प्ट्ससाठी `ChatPromptTemplate` वापरा.
- टाइप केलेल्या रिस्पॉन्ससाठी `StrOutputParser` किंवा JSON पार्सरने आउटपुट पार्स करा.
```python
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o-mini")
prompt = ChatPromptTemplate.from_template(
"""
खालील टेक्स्टचा 3 बुलेट पॉईंट्समध्ये सारांश द्या:
---
{text}
"""
)
parser = StrOutputParser
chain = prompt | llm | parser
summary = chain.invoke({"text": "LangChain RAG आणि टूल्ससह LLM ॲप्स तयार करण्यात मदत करते."})
print(summary)

# pip install faiss-cpu tiktoken
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
# डॉक्युमेंट्स तयार करा
texts = .
---
## प्रोटोटाइप ते प्रोडक्शन: स्टेप-बाय-स्टेप ब्लूप्रिंट
### स्टेप 1: यूजर स्टोरी डिफाइन करा
- यूजर कोण आहे? ते कोणते काम पूर्ण करण्याचा प्रयत्न करत आहेत?
- उदाहरण: “एक सपोर्ट एजंट जो अंतर्गत डॉक्स आणि अलीकडील तिकिटांमधील प्रॉडक्ट प्रश्नांची उत्तरे देतो.”
### स्टेप 2: मिनिमम वायबल स्टॅक निवडा
- मॉडेल: वाजवी किंमतीचे, विश्वसनीय मॉडेल निवडा (उदा. GPT-4o-mini किंवा फ्रंटियर ओपन मॉडेल).
- डेटा: तुम्हाला आता RAG ची आवश्यकता आहे का ते ठरवा. असल्यास, स्थानिक पातळीवर FAISS ने सुरुवात करा.
- I/O: जलद इटरेटिव्हसाठी LCEL वापरा; कस्टम ग्लू कोड टाळा.
### स्टेप 3: क्लीन RAG लूप लागू करा
- डॉक्स योग्यरित्या स्प्लिट करा.
- एम्बेडिंग्ज इंडेक्स करा.
- संदर्भ आणि कोटेशनसह प्रॉम्प्ट करा.
- जेव्हा कोणताही संबंधित संदर्भ आढळला नाही, तेव्हा हेलुसिनेशन टाळण्यासाठी गार्डरेल जोडा.
```python
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
qa_prompt = ChatPromptTemplate.from_template(
"""
केवळ खालील संदर्भ वापरून प्रश्नाचे उत्तर द्या. जर उत्तर संदर्भात नसेल, तर “मला माहीत नाही” असे सांगा. cited doc IDs समाविष्ट करा.
संदर्भामध्ये नसेल, तर "मला माहीत नाही." म्हणा. cited doc IDs समाविष्ट करा.
संदर्भ:
{context}
प्रश्न: {question}
"""
)
parser = StrOutputParser
rag_chain = (RunnableParallel(context=retriever, question=RunnableLambda(lambda x: x.
### स्टेप 5: टाइप केलेले आउटपुट आणि व्हॅलिडेशन
- API रिस्पॉन्ससाठी स्ट्रक्चर लागू करण्यासाठी `PydanticOutputParser` किंवा JSON स्कीमा वापरा.
- मॉडेल ड्रिफ्ट पकडण्यासाठी फील्ड्स व्हॅलिडेट करा.
### स्टेप 6: रिअल टास्कसाठी टूलिंग आणि फंक्शन कॉलिंग
- क्वचितच टूल्स सादर करा.
- सामान्य टूल्स: कॅल्क्युलेटर, वेब सर्च, SQL क्वेरी एक्झिक्युटर, कोड रनर.
- टूल क्षमता डॉकस्ट्रिंगमध्ये स्पष्टपणे सांगा.
### स्टेप 7: हार्डनिंग
- रेट लिमिट आणि रिट्राय स्ट्रॅटेजी.
- टाइमआउट्स आणि सर्किट ब्रेकर्स.
- सेफ्टी फिल्टर्स आणि कंटेंट चेक.
### स्टेप 8: इव्हॅल्युएशन आणि सतत सुधारणा
- गोल्डन डेटासेट्स (इनपुट → अपेक्षित आउटपुट) सह चाचणी करा.
- विश्‍वासार्हता, उत्तराची पूर्णता आणि कोटेशन अचूकतेचे मूल्यांकन करा.
- रिट्रीव्हल हिट रेट आणि लेटेंसी मोजा.
---
## सामान्य पॅटर्न आणि अडचणी
- साध्या गोष्टींपासून सुरुवात करा: एजंट्सपूर्वी चेन्स. तुम्हाला अंदाज लावता येईल आणि खर्च कमी होईल.
- चंकिंग महत्त्वाचे आहे: चंक आकार/ओव्हरलॅप ट्यून केल्याने मॉडेल स्वॅपपेक्षा रिट्रीव्हल गुणवत्ता अधिक बदलू शकते.
- प्रॉम्प्ट लीकेज: सिस्टीम प्रॉम्प्टमध्ये अनावश्यक गोष्टी टाकू नका; त्यांना केंद्रित ठेवा.
- निर्धार: मूल्यांकन आणि गंभीर वर्कफ्लोसाठी `temperature=0` सेट करा.
- स्ट्रीमिंग UX: सिस्टीम ॲसेट्स फेच करत असताना किंवा संदर्भ प्रीलोड करत असताना UI मध्ये टोकन्स स्ट्रीम करा.
- स्ट्रक्चर्ड आउटपुट: डाउनस्ट्रीम इंटिग्रेशन वेदनादायक करण्यासाठी पार्सर वापरा.
---
## एक पूर्ण मिनी प्रोजेक्ट: साइटेशनसह डॉक्स Q&A
हे उदाहरण सर्वकाही एकत्र बांधते: इंजेक्शन, RAG, उत्तर निर्मिती आणि स्ट्रीमिंग.
```python
# pip install langchain langchain-openai faiss-cpu tiktoken
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableParallel, RunnableLambda
# 1) इंजेस्ट
corpus = {
"pricing": "आमचा प्रो प्लॅन 1M संदर्भ टोकन्सला सपोर्ट करतो आणि त्यात प्रायॉरिटी सपोर्ट समाविष्ट आहे.",
"limits": "प्रो युजर्ससाठी API रेट लिमिट 60 रिक्वेस्ट्स प्रति मिनिट आहे.",
"security": "ॲडमिनने लॉगिंग डिसेबल न केल्यास आम्ही 30 दिवसांसाठी लॉग स्टोअर करतो.",
}
splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)
all_chunks, ids = [], []
for doc_id, text in corpus.items:
for i, chunk in enumerate(splitter.split_text(text)):
all_chunks.append(chunk)
ids.append(f"{doc_id}-{i}")
# 2) इंडेक्स
db = FAISS.from_texts(all_chunks, OpenAIEmbeddings)
retriever = db.as_retriever(k=4)
# 3) प्रॉम्प्ट
prompt = ChatPromptTemplate.from_template(
"""
तुम्ही सपोर्ट असिस्टंट आहात. उत्तर देण्यासाठी संदर्भ वापरा.
खात्री नसल्यास, “मला माहीत नाही” असे सांगा. सोर्स IDs चे साइटेशन समाविष्ट करा.
संदर्भ:
{context}
प्रश्न: {question}
"""
)
# 4) मॉडेल आणि पार्सर
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
parser = StrOutputParser
# 5) चेन कंपोज करा
rag = (
RunnableParallel(
context=retriever,
question=RunnableLambda(lambda x: x["question"]) # पास-थ्रू
)
| prompt
| llm
| parser
)
# 6) प्रश्न विचारा
for chunk in rag.stream({"question": "प्रो रेट लिमिट्स आणि लॉग रिटेन्शन काय आहेत?"}):
print(chunk, end="", flush=True)