LangChain के साथ प्रॉम्प्ट इंजीनियरिंग का परिचय

LangChain एक ओपन-सोर्स फ्रेमवर्क है, जिसे एप्लिकेशन बनाने के लिए इस तरह डिज़ाइन किया गया है कि आप आसानी से GPT, LLaMA, Mistral जैसे भाषा मॉडलों का उपयोग कर सकें।

LangChain की सबसे शक्तिशाली विशेषताओं में से एक है उन्नत प्रॉम्प्ट इंजीनियरिंग का समर्थन। प्रॉम्प्ट इंजीनियरिंग का अर्थ है ऐसे प्रॉम्प्ट्स की रचना और अनुकूलन जो भाषा मॉडल से सबसे सटीक और प्रासंगिक उत्तर प्राप्त करें।

इस पोस्ट में, हम प्रॉम्प्ट्स की बुनियादी बातें, LangChain प्रॉम्प्ट्स का उपयोग कैसे करता है, प्रॉम्प्ट टेम्पलेट्स, मेमोरी, एजेंट्स और चेन्स पर चर्चा करेंगे। इन प्रत्येक मुख्य अवधारणाओं के लिए हम Python में कई कोड उदाहरण भी देखेंगे, ताकि इस ट्यूटोरियल के अंत तक आप Python में LangChain फ्रेमवर्क का उपयोग करके अपने स्वयं के एप्लिकेशन बनाने में सहज हों।

जानना चाहते हैं कि LangChain और GPT का उपयोग करके एक साधारण AI एजेंट कैसे बनाया जा सकता है? हमारा Prompt Engineering with GPT & LangChain AI Code-Along देखें:

Prompt Engineering क्या है?

चित्र: लेखक द्वारा

हमारे पास प्रॉम्प्ट इंजीनियरिंग पर एक संपूर्ण गाइड है, लेकिन त्वरित पुनरावलोकन के रूप में—यह ऐसे टेक्स्ट इनपुट बनाना है जो जनरेटिव AI मॉडलों से प्रभावी ढंग से संवाद करें। ये प्रॉम्प्ट्स, जो प्राकृतिक भाषा में लिखे जाते हैं, उस कार्य को निर्दिष्ट करते हैं जिसे हम AI से करवाना चाहते हैं।

इनका स्वरूप विविध हो सकता है—किसी गणितीय प्रमेय की व्याख्या पूछने जैसे साधारण प्रश्नों से लेकर किसी विशिष्ट थीम पर कविता लिखवाने जैसे रचनात्मक अनुरोधों तक।

प्रॉम्प्ट इंजीनियरिंग में कुंजी केवल यह नहीं है कि आप क्या पूछते हैं, बल्कि यह भी है कि आप कैसे पूछते हैं। इसमें उचित शब्दों का चयन, एक विशेष टोन या शैली निर्धारित करना, आवश्यक संदर्भ प्रदान करना, या यहां तक कि AI के लिए एक भूमिका परिभाषित करना शामिल हो सकता है—जैसे उससे किसी विशिष्ट भाषा के मूल वक्ता की तरह उत्तर देने के लिए कहना।

कुछ मामलों में, प्रॉम्प्ट्स में उदाहरण भी शामिल हो सकते हैं ताकि AI की सीखने की प्रक्रिया को दिशा मिले। यह तकनीक few-shot learning के नाम से जानी जाती है और जटिल कार्यों के लिए विशेष रूप से प्रभावी हो सकती है।

जब ऐसे मॉडलों से काम किया जाता है जो छवियां या ऑडियो बनाते हैं, तो प्रॉम्प्ट्स आमतौर पर इच्छित आउटपुट का विस्तार से वर्णन करते हैं—विषय और शैली से लेकर रचना और अंतिम परिणाम के मूड तक। प्रॉम्प्ट इंजीनियरिंग की कला इन तत्वों को समायोजित कर AI को वांछित परिणाम उत्पन्न करने की दिशा में ले जाने में निहित है।

प्रॉम्प्ट्स की बुनियाद

चित्र: लेखक द्वारा

प्रॉम्प्ट्स वे इनपुट होते हैं जो बड़े भाषा मॉडलों (LLMs) को वांछित प्रतिक्रिया प्राप्त करने के लिए दिए जाते हैं। उपयोगी आउटपुट हासिल करने के लिए अच्छे से डिज़ाइन किए गए प्रॉम्प्ट्स अत्यंत महत्वपूर्ण हैं। प्रॉम्प्ट इंजीनियरिंग का लक्ष्य ऐसे प्रॉम्प्ट्स बनाना है जो सटीक, प्रासंगिक और सहायक LLM प्रतिक्रियाएं दें।

एक अच्छा प्रॉम्प्ट आम तौर पर ये चार अवयव रखता है:

1. निर्देश - मॉडल को बताएं कि क्या करना है, दी गई जानकारी का कैसे उपयोग करना है, क्वेरी के साथ क्या करना है, और आउटपुट कैसे बनाना है।
2. उदाहरण इनपुट - मॉडल को अपेक्षित चीज़ दिखाने के लिए नमूना इनपुट दें।
3. उदाहरण आउटपुट - संबंधित नमूना आउटपुट प्रदान करें।
4. क्वेरी - वास्तविक इनपुट जिसे आप मॉडल से प्रोसेस कराना चाहते हैं।

क्वेरी को छोड़कर बाकी सब वैकल्पिक है, लेकिन वे प्रतिक्रिया की गुणवत्ता पर महत्वपूर्ण प्रभाव डाल सकते हैं—खासकर वे निर्देश जो LLM को कार्य और अपेक्षित उत्तर पर मार्गदर्शन देते हैं।

उदाहरण, दिए गए उदाहरण इनपुट के लिए वांछित आउटपुट का प्रारूप दर्शाते हैं।

क्वेरी वह प्रश्न या अनुरोध है जो LLM से किया जाता है।

प्रभावी प्रॉम्प्ट्स बनाना, सुलझाई जा रही समस्या के आधार पर इन तत्वों को रचनात्मक ढंग से संयोजित करना है।

LangChain प्रॉम्प्ट्स

LangChain प्रॉम्प्ट्स के निर्माण और उनके साथ काम करने में सहायता के लिए विभिन्न क्लासेज़ और फंक्शंस प्रदान करता है, जिससे भाषा मॉडलों से जुड़ी जटिलताओं को संभालना आसान हो जाता है।

LangChain, `PromptTemplate` ऑब्जेक्ट के माध्यम से प्रॉम्प्ट इंजीनियरिंग के लिए फर्स्ट-क्लास समर्थन देता है।

प्रॉम्प्ट टेम्पलेट्स, भाषा मॉडलों के लिए क्वेरी तैयार करने के संरचित मार्गदर्शक के रूप में काम करते हैं।

ये टेम्पलेट्स आमतौर पर निर्देशों, उदाहरण इनपुट्स (few-shot examples) के चयन, और विशिष्ट कार्यों के लिए उपयुक्त प्रश्नों और संदर्भों से मिलकर बनते हैं।

LangChain का उद्देश्य ऐसे टेम्पलेट्स डिज़ाइन करना है जो विभिन्न भाषा मॉडलों के साथ संगत हों, ताकि टेम्पलेट्स को अलग-अलग मॉडलों के बीच आसानी से स्थानांतरित किया जा सके।

संक्षेप में, आप PromptTemplate क्लास का उपयोग स्ट्रिंग प्रॉम्प्ट के लिए एक टेम्पलेट बनाने में कर सकते हैं।

from langchain.prompts import PromptTemplate


prompt_template = PromptTemplate.from_template(
    "Tell me a {adjective} joke about {content}."
)
prompt_template.format(adjective="sad", content="data scientists")संचालित द्वारा

आउटपुट:

>>> 'Tell me a sad joke about data scientists.'

किसी वैरिएबल का होना आवश्यक नहीं है। यदि आपके पास कोई वैरिएबल नहीं भी है, तो भी आप इस क्लास का उपयोग करके एक प्रॉम्प्ट बना सकते हैं।

from langchain.prompts import PromptTemplate
prompt_template = PromptTemplate.from_template("Tell me a joke")
prompt_template.format()संचालित द्वारा

आउटपुट:

>>> 'Tell me a joke'

मान लीजिए आप एक चैट एप्लिकेशन बना रहे हैं जहां आपको हर बार उपयोगकर्ता द्वारा नया संदेश भेजने पर संदेश इतिहास सहेजकर LLM को भेजना पड़ता है। इसे मैन्युअल रूप से करना समय लेने वाला है।

समर्थित चैट मॉडलों के लिए, आप इसकी जगह ChatPromptTemplate का उपयोग कर सकते हैं:

from langchain.prompts import ChatPromptTemplate


chat_template = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a helpful AI bot. Your name is {name}."),
        ("human", "Hello, how are you doing?"),
        ("ai", "I'm doing well, thanks!"),
        ("human", "{user_input}"),
    ]
)


messages = chat_template.format_messages(name="Bob", user_input="What is your name?")


print(messages)संचालित द्वारा

आउटपुट:

>>> [SystemMessage(content='You are a helpful AI bot. Your name is Bob.'),

>>> HumanMessage(content='Hello, how are you doing?'),

>>> AIMessage(content="I'm doing well, thanks!"),

>>> HumanMessage(content='What is your name?')]

तो आप सोच रहे होंगे, हमें PromptTemplates की आवश्यकता क्यों है? हम सीधे स्ट्रिंग प्रॉम्प्ट LLM को क्यों नहीं दे सकते? LangChain के PromptTemplate का उपयोग करने के कुछ अच्छे कारण यह हैं:

• प्रॉम्प्ट टेम्पलेट्स पुन: प्रयोज्य होते हैं—आप एक बार प्रॉम्प्ट बनाकर उसे कई स्थितियों में उपयोग कर सकते हैं, जैसे अलग-अलग लेखों का सारांश बनाते समय हर बार प्रॉम्प्ट न लिखना पड़े।
• ये प्रॉम्प्ट्स के फ़ॉर्मेटिंग को वास्तविक मॉडल कॉल से अलग कर देते हैं, जिससे कोड अधिक मॉड्यूलर बनता है और टेम्पलेट या मॉडल को स्वतंत्र रूप से अपडेट किया जा सकता है।
• टेम्पलेट्स का उपयोग कोड की पठनीयता बढ़ाता है, क्योंकि वे जटिल लॉजिक को स्पष्ट नामित वैरिएबल्स के साथ सरल रूप में समेटते हैं।
• रखरखाव आसान हो जाता है, क्योंकि प्रॉम्प्ट लॉजिक में बदलाव एक ही केंद्रीय स्थान पर करने होते हैं—हर अलग-अलग प्रॉम्प्ट में नहीं।

LangChain मेमोरी

ऐसी भाषा मॉडल एप्लिकेशनों में जो चैटिंग शामिल करती हैं, सिस्टम के लिए पिछली बातचीत याद रखना महत्वपूर्ण होता है।

सामान्य चैट की तरह, सिस्टम को यह देखने में सक्षम होना चाहिए कि पहले क्या कहा गया था।

सबसे सरल स्तर पर, इसका मतलब है कि सिस्टम कुछ पिछले संदेश देख सकता है। लेकिन अधिक उन्नत सिस्टम अधिक विवरण याद रखते हैं—जैसे अलग-अलग विषयों के तथ्य और उनके आपसी संबंध।

पिछली बातचीत याद रखने की इस क्षमता को ही "मेमोरी" कहा जाता है। LangChain इन चैट सिस्टम्स में मेमोरी जोड़ने में मदद करता है।

LangChain में मेमोरी दो मुख्य काम करती है:

1. क्वेरी को LLM को भेजने से पहले, सिस्टम अपनी मेमोरी से पढ़कर उपयोगकर्ता से प्राप्त प्रारंभिक इनपुट प्रॉम्प्ट को समृद्ध करता है।
2. LLM द्वारा प्रतिक्रिया लौटाए जाने पर, अंतिम आउटपुट उपयोगकर्ता को लौटाने से पहले उसे भविष्य की बातचीतों के लिए मेमोरी में लिख देता है।

LangChain में मेमोरी (चित्र स्रोत)

LangChain में Memory फीचर का उपयोग करने के लिए आप ConversationBufferMemory क्लास का उपयोग कर सकते हैं।

from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory(return_messages=True)
memory.chat_memory.add_user_message("hi!")
memory.chat_memory.add_ai_message("what's up?")
memory.chat_memory.add_user_message("how are you doing?")
memory.chat_memory.add_ai_message("I am fine, thank you and you?")


# to check the variables history
memory.load_memory_variables({})
संचालित द्वारा

आउटपुट:

>>> {'history': [HumanMessage(content='hi!'),

>>> AIMessage(content="what's up?"),

>>> HumanMessage(content='how are you doing?'),

>>> AIMessage(content='I am fine, thank you and you?')]}

यह एक डिक्शनरी लौटाता है जहां डिफ़ॉल्ट कुंजी history होती है। यह कुंजी संदेशों की एक सूची की ओर इशारा करती है, और ये संदेश या तो मानव (HumanMessage) के होते हैं या LLM (AIMessage) के।

LangChain चेन्स

सरल कार्यों के लिए एकल LLM (Large Language Model) ठीक काम करता है। हालांकि, अधिक जटिल कार्यों के लिए आमतौर पर कई चरणों और/या मॉडलों को जोड़ना पड़ता है।

LangChain में Chains का लिगेसी उपयोग Chain इंटरफेस के माध्यम से होता है।

नया और अनुशंसित तरीका है LangChain Expression Language (LCEL)। यद्यपि नए प्रोजेक्ट्स के लिए LCEL वरीय है, Chain विधि अभी भी उपयोगी और समर्थित है।

from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema import StrOutputParser


model = ChatOpenAI(openai_api_key = “...”)


prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "You're a expert data scientist and machine learning engineer who offer its expertise and responds to the point and accurately.",
        ),
        ("human", "{question}"),
    ]
)
runnable = prompt | model | StrOutputParser()


for chunk in runnable.stream({"question": "How is machine learning different than deep learning?"}):
    print(chunk, end="", flush=True)संचालित द्वारा

आउटपुट:

>>> Machine learning and deep learning are subfields of artificial intelligence (AI) that involve training models to make predictions or decisions based on data. While there is an overlap between the two, they ……..

runnable बनाने का तरीका Python में बहुत मानक नहीं दिखता, लेकिन यह | एक पाइप ऑपरेटर है। Prompt | model | StrOutputParser() का मतलब है कि Prompt को model से पास किया जाता है और उसका आउटपुट आगे StrOutputParser() से होकर जाता है। चेन का हर खंड किसी न किसी तरह डेटा को रूपांतरित करता है।

LangChain का उपयोग करके बनाए जा सकने वाले रोचक उपयोग-केस और एप्लिकेशनों के बारे में और जानना चाहते हैं? हमारा Engineering and Data Application use-cases ट्यूटोरियल देखें।

LangChain एजेंट्स

एजेंट्स की मूल अवधारणा, एक भाषा मॉडल का उपयोग करते हुए कार्यों की एक शृंखला का चयन करने पर आधारित है।

चेन्स के विपरीत, जहाँ कार्यों का क्रम पहले से निर्धारित होता है और कोड में निहित रहता है, एजेंट्स उपयुक्त कार्यों और उनके क्रम की पहचान करने के लिए भाषा मॉडल को निर्णय-निर्धारण उपकरण के रूप में उपयोग करते हैं।

LangChain के Agents में तीन प्रमुख अवधारणाएँ हैं:

1. टूल्स: LLM के लिए उपलब्ध टूल्स का विवरण
2. उपयोगकर्ता इनपुट: कार्य का उच्च-स्तरीय उद्देश्य
3. मध्यवर्ती चरण: उपयोगकर्ता इनपुट हासिल करने के लिए पहले निष्पादित किए गए किसी भी (action, tool output) युग्म

टूल्स वे कार्यक्षमताएँ हैं जिन्हें कोई एजेंट सक्रिय कर सकता है। टूल डिज़ाइन के दो महत्वपूर्ण पहलू हैं:

• सुनिश्चित करना कि एजेंट के पास उपयुक्त टूल्स तक पहुँच हो।
• टूल्स को इस तरह परिभाषित करना कि वे एजेंट के लिए अधिकतम उपयोगी हों।

विभिन्न नियमित गतिविधियों के लिए, किसी एजेंट को परस्पर जुड़े टूल्स का एक सेट चाहिए। इसे संबोधित करने के लिए, LangChain टूलकिट्स की अवधारणा प्रस्तुत करता है। आरंभ करने के लिए LangChain कई प्रकार के टूलकिट्स प्रदान करता है।

Agents के बारे में अधिक जानने के लिए यह आधिकारिक LangChain गाइड देखें।

श्रेय: इस ब्लॉग में कुछ उदाहरण आधिकारिक LangChain दस्तावेज़ का उपयोग करके तैयार किए गए हैं।

निष्कर्ष

प्रॉम्प्ट्स को डिज़ाइन करने के लिए संरचित दृष्टिकोण प्रदान करके, LangChain न केवल अलग-अलग भाषा मॉडलों के साथ इंटरेक्शन की प्रक्रिया को सरल बनाता है बल्कि उनके आउटपुट की दक्षता और प्रासंगिकता को भी अधिकतम करता है। LangChain में PromptTemplate और Memory जैसी विशेषताएँ, प्रॉम्प्ट इंजीनियरिंग में लचीलापन और सटीकता के विचारशील एकीकरण को दर्शाती हैं—जो सरल क्वेरी से लेकर जटिल संवादात्मक संदर्भों तक की विस्तृत श्रेणी की जरूरतों को पूरा करती हैं।

LangChain की Chains और Agents में उपलब्ध उन्नत विशेषताएँ, किसी भी आधारभूत LLM के साथ कुछ ही पंक्तियों के कोड में बनाए जा सकने वाले एप्लिकेशनों की संभावनाओं को और आगे बढ़ाती हैं—और चुनने के लिए विकल्प भी अनेक हैं।

चाहे सरल कार्य हों या जटिल एप्लिकेशन, प्रॉम्प्ट इंजीनियरिंग के प्रति LangChain का दृष्टिकोण काफी सरल, स्पष्ट और अपनाने में आसान है।

और सीखना चाहते हैं? DataCamp पर How to Build LLM Applications with LangChain का भाग 1 देखें।