# 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(
"""
ફક્ત નીચેના CONTEXT નો ઉપયોગ કરીને પ્રશ્નનો જવાબ આપો. જો જવાબ નથી
સંદર્ભમાં, કહો "મને ખબર નથી." ટાંકવામાં આવેલા ડોક IDs નો સમાવેશ કરો.
CONTEXT:
{context}
QUESTION: {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(
"""
તમે સપોર્ટ સહાયક છો. જવાબ આપવા માટે CONTEXT નો ઉપયોગ કરો.
જો ખાતરી ન હોય, તો કહો "મને ખબર નથી." સ્ત્રોત IDs ના ટાંકણો શામેલ કરો.
CONTEXT:
{context}
QUESTION: {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)