# pip install langchain langchain-openai
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
# 1) Model
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
# 2) Prompt
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}
கேள்வி: {question}
"""
)
parser = StrOutputParser
rag_chain = (RunnableParallel(context=retriever, question=RunnableLambda(lambda x: x.
### படி 5: தட்டச்சு செய்யப்பட்ட வெளியீடுகள் மற்றும் சரிபார்ப்பு
- API பதில்களுக்கான கட்டமைப்பை செயல்படுத்த `PydanticOutputParser` அல்லது JSON ஸ்கீமாவைப் பயன்படுத்தவும்.
- மாதிரி விலகலைப் பிடிக்க புலங்களைச் சரிபார்க்கவும்.
### படி 6: உண்மையான பணிகளுக்கான கருவி மற்றும் செயல்பாட்டு அழைப்பு
- கருவிகளை குறைவாக அறிமுகப்படுத்தவும்.
- பொதுவான கருவிகள்: கால்குலேட்டர், வலை தேடல், SQL வினவல் எக்சிகியூட்டர், கோட் ரன்னர்.
- கருவி திறன்களை டாகுமென்ட்ஸ்ட்ரிங்ஸில் தெளிவாக விவரிக்கவும்.
### படி 7: கடினப்படுத்துதல்
- விகித வரம்பு மற்றும் மறுமுயற்சி உத்திகள்.
- காலக்கெடு மற்றும் சர்க்யூட் பிரேக்கர்கள்.
- பாதுகாப்பு வடிகட்டிகள் மற்றும் உள்ளடக்கச் சோதனைகள்.
### படி 8: மதிப்பீடு மற்றும் தொடர்ச்சியான மேம்பாடு
- தங்க தரவுத்தொகுப்புகளுடன் சோதிக்கவும் (உள்ளீடு → எதிர்பார்க்கப்படும் வெளியீடு).
- நம்பகத்தன்மை, பதில் முழுமை மற்றும் மேற்கோள் துல்லியம் ஆகியவற்றை மதிப்பிடுங்கள்.
- மீட்டெடுப்பு வெற்றி விகிதம் மற்றும் தாமதத்தை அளவிடவும்.
---
## பொதுவான வடிவங்கள் மற்றும் கோட்சாஸ்
- எளிமையாகத் தொடங்குங்கள்: முகவர்களுக்கு முன் சங்கிலிகள். நீங்கள் கணிப்பு மற்றும் குறைந்த செலவைப் பெறுவீர்கள்.
- Chunking முக்கியமானது: மாதிரி மாற்றத்தை விட chunk அளவு/மேலெழுதலை சரிசெய்வது மீட்டெடுப்பு தரத்தை மாற்றலாம்.
- தூண்டுதல் கசிவு: கணினி தூண்டுதல்களில் சமையலறை மடுவை நிரப்ப வேண்டாம்; அவற்றை மையமாக வைத்திருங்கள்.
- தீர்மானம்: மதிப்பீடு மற்றும் முக்கியமான பணிப்பாய்வுகளுக்கு `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": "எங்கள் 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}
கேள்வி: {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)