# 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 ಗೆ ಟೋಕನ್‌ಗಳನ್ನು ಸ್ಟ್ರೀಮ್ ಮಾಡಿ.
- ರಚನಾತ್ಮಕ ಔಟ್‌ಪುಟ್‌ಗಳು: ಕೆಳಹರಿವಿನ ಏಕೀಕರಣವನ್ನು ನೋವುರಹಿತವಾಗಿಸಲು ಪಾರ್ಸರ್‌ಗಳನ್ನು ಬಳಸಿ.
---
## ಒಂದು ಸಂಪೂರ್ಣ ಮಿನಿ ಪ್ರಾಜೆಕ್ಟ್: ಉಲ್ಲೇಖಗಳೊಂದಿಗೆ ಡಾಕ್ಸ್ ಪ್ರಶ್ನೆ ಮತ್ತು ಉತ್ತರ
ಈ ಉದಾಹರಣೆಯು ಎಲ್ಲವನ್ನೂ ಒಟ್ಟಿಗೆ ಜೋಡಿಸುತ್ತದೆ: ಇಂಜೆಕ್ಷನ್, 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": "ನಮ್ಮ Pro ಯೋಜನೆಯು 1M ಸಂದರ್ಭ ಟೋಕನ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಮತ್ತು ಆದ್ಯತೆಯ ಬೆಂಬಲವನ್ನು ಒಳಗೊಂಡಿದೆ.",
"limits": "Pro ಬಳಕೆದಾರರಿಗೆ 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": "Pro ದರ ಮಿತಿಗಳು ಮತ್ತು ಲಾಗ್ ಧಾರಣ ಯಾವುವು?"}):
print(chunk, end="", flush=True)