# 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 ను మాత్రమే ఉపయోగించి ప్రశ్నకు సమాధానం ఇవ్వండి. సమాధానం కాకపోతే
సందర్భంలో, "నాకు తెలియదు." అని చెప్పండి. ఉదహరించిన డాక్ IDలను చేర్చండి.
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 ను ఉపయోగించండి.
ఖచ్చితంగా లేకుంటే, "నాకు తెలియదు." అని చెప్పండి. మూలం IDల యొక్క సైటేషన్‌లను చేర్చండి.
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)