LangServe और MinIO एकीकरण के साथ LangChain API को आसानी से लॉन्च करें

लैंगचेन की नवोन्मेषी दुनिया में हमारी यात्रा ने डेटा प्रबंधन और अनुप्रयोग कार्यक्षमता को बदलने में इसकी पर्याप्त क्षमताओं का अनावरण किया है।

पिछली चर्चाओं के माध्यम से, हमने LangChain की जटिल क्षमताओं की खोज करते हुए कई विषयों पर गहन चर्चा की। इस लेख में, हम "MinIO के साथ Langchain एजेंटों को सशक्त बनाना" में शामिल अवधारणाओं पर निर्माण करेंगे क्योंकि हम अतिरिक्त क्षमताओं को समाहित करने और LangServe के माध्यम से कस्टम एजेंट को तैनात करने के लिए एक MinIO एजेंट की कार्यक्षमता का विस्तार करते हैं।

• LangChain के साथ S3 बकेट रिट्रीवल का नवाचार : कस्टम संवादी एआई एजेंट तैयार करने के लिए लैंगचेन के एस3 लोडर और ओपनएआई एपीआई का लाभ उठाने पर एक वॉकथ्रू, डेटा प्रबंधन के लिए एक सुव्यवस्थित दृष्टिकोण स्थापित करना।

  
  

• मिनियो के साथ लैंगचेन एजेंटों को सशक्त बनाना मिनियो के उपयोग पर गहन जानकारी , जिसमें दर्शाया गया है कि किस प्रकार लैंगचेन, ओपनएआई के जीपीटी के साथ मिलकर एआई और एमएल डाटा प्रोसेसिंग में नई सीमाओं की ओर अग्रसर है।

  
  

इन जानकारियों के आधार पर, अब हम अपना ध्यान इस ओर केंद्रित करते हैं लैंगसर्व , लैंगचेन अनुप्रयोगों को विकास से लेकर परिनियोजन तक परिवर्तित करने में एक महत्वपूर्ण उपकरण है, जो उत्पादन-तैयार एपीआई लॉन्च करने की प्रक्रिया को सरल बनाता है।

लैंगसर्व: लैंगचेन अनुप्रयोगों के लिए तैनाती को सरल बनाना

लैंगसर्व डेवलपर्स के लिए आधारशिला के रूप में खड़ा है, जो पारंपरिक रूप से API परिनियोजन से जुड़ी जटिलताओं को समाप्त करता है। यह मिनियो-एकीकृत लैंगचेन अनुप्रयोगों को सुलभ, उपयोगकर्ता-अनुकूल API में आसानी से बदलने में सक्षम बनाता है। यहाँ बताया गया है कि लैंगसर्व परिनियोजन परिदृश्य को कैसे पुनर्परिभाषित करता है:

• स्वचालित API समापन बिंदु निर्माण: लैंगसर्व की स्वचालन क्षमताएं आसानी से आवश्यक API समापन बिंदु उत्पन्न करती हैं, विकास प्रयासों को सुव्यवस्थित करती हैं और तैनाती के समय को काफी कम करती हैं।

  
  

• स्कीमा निर्माण और सत्यापन: अपने बुद्धिमान स्कीमा अनुमान के साथ, लैंगसर्व यह सुनिश्चित करता है कि एपीआई अच्छी तरह से परिभाषित इंटरफेस प्रदान करें, जिससे आसान एकीकरण और निर्बाध उपयोगकर्ता अनुभव की सुविधा मिले।

  
  

• अनुकूलन योग्य एंडपॉइंट कॉन्फ़िगरेशन: लैंगसर्व, विभिन्न अनुप्रयोग आवश्यकताओं के अनुरूप विभिन्न प्रकार के एंडपॉइंट प्रदान करता है, जिसमें समकालिक संचालन से लेकर वास्तविक समय अपडेट तक शामिल हैं, जिससे डेवलपर्स को अद्वितीय लचीलापन मिलता है।

  
  

• सहज एकीकरण: शायद इसकी सबसे आकर्षक विशेषता, LangServe की मौजूदा LangChain कोड के साथ सहज एकीकरण करने की क्षमता का अर्थ है कि डेवलपर्स बिना किसी महत्वपूर्ण परिवर्तन के अपने वर्तमान कोडबेस और विशेषज्ञता का लाभ उठा सकते हैं।

लैंगचेन और लैंगसर्व में गहराई से गोता लगाना

हम निम्नलिखित चरणों में MinIO को LangChain के साथ एकीकृत करने की प्रक्रिया में गहराई से उतरेंगे।

1. langchain-cli साथ एक LangChain ऐप बनाएं।
2. agent.py फ़ाइल में एक कस्टम LangChain एजेंट विकसित करें।
3. LangServe API के रूप में चलाने के लिए server.py में हमारे एजेंट को क्रियान्वित करें।

ऐप्स बनाने के लिए LangChain के कमांड-लाइन इंटरफ़ेस का उपयोग करना

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

LangChain अपने langchain-cli का उपयोग करके एप्लिकेशन बनाने की एक सुविधाजनक और सरल विधि प्रदान करता है पुस्तकालय जिसे pip के साथ इंस्टॉल किया जा सकता है। यह पैकेज एक इंटरफ़ेस प्रदान करता है जो उपयोगकर्ताओं को मौजूदा का उपयोग करके आसानी से नए एप्लिकेशन बनाने की अनुमति देता है लैंगचेन ऐप टेम्पलेट्स या अपना स्वयं का निर्माण करें.

एक नया LangChain अनुप्रयोग बनाने के लिए हम एक वर्चुअल वातावरण बनाने और langchain-cli पैकेज स्थापित करने के लिए निम्नलिखित कमांड से शुरुआत कर सकते हैं:

 mkdir minio-langserve-testing cd minio-Langserve-testing python -m venv .myenv source .myenv/bin/activate pip install langchain-cli 

langchain-cli का उपयोग करके एक नया ऐप बनाने के लिए हम अपने टर्मिनल में langchain टाइप कर सकते हैं, my-app नामक एक नई एप्लिकेशन डायरेक्टरी बनाने के लिए निम्नलिखित कमांड लिखी जाती है।

 langchain app new my-app

उपरोक्त कमांड के साथ बनाया गया लैंगचेन ऐप, विकास के लिए एक सुसंगत वातावरण बनाकर सभी भारी काम करता है। बॉक्स से बाहर एक नए लैंगचेन एप्लिकेशन की संरचना इस तरह दिखती है:

 ./my-app ├── Dockerfile ├── README.md ├── app │ ├── __init__.py │ └── server.py ⇐ (This is where we will import our agent into) ├── packages ⇐ (This directory is where we will write our agent) │ └── README.md └── pyproject.toml

निम्नलिखित चरणों में हम packages/agent.py नामक एक नई फ़ाइल लिखकर और app/server.py में परिवर्तन करके नव निर्मित LangChain एप्लिकेशन ( my-app ) में परिवर्तन करेंगे।

इस लेख में हम जिन फ़ाइलों पर चर्चा करेंगे वे ये हैं:

• my-app/packages/agent.py
• my-app/app/server.py

LangServe के साथ तैनात करने के लिए LangChain MinIO एजेंट का विकास करना

LangServe के साथ MinIO-एकीकृत LangChain एजेंट की तैनाती को दर्शाने के लिए, हम एजेंट चेन कोड को agent.py में सहेजकर शुरू करेंगे।

सबसे पहले, आइए एक minio_client इनिशियलाइज़ करें जो "play.min.io:443" पब्लिक सर्वर से कनेक्ट होता है। यह फ़ाइल अंततः LangChain के agent_executor कॉल करेगी, जिससे हम इसे LangServe के add_route रैपर में पास कर सकेंगे।

आरंभ करने के लिए, टेक्स्ट एडिटर का उपयोग करके agent.py फ़ाइल खोलें:

 sudo nano packages/agent.py

फ़ाइल की शुरुआत में, आवश्यक पैकेज आयात करें, जैसे os , io , minio और ChatOpenAI :

 import os import io from minio import Minio from minio.error import S3Error from langchain_openai import ChatOpenAI os.environ["OPENAI_API_KEY"] = "<<Your API Key Here>>" # Initialize llm llm = ChatOpenAI(api_key=os.environ["OPENAI_API_KEY"]) # Initialize MinIO client minio_client = Minio('play.min.io:443', access_key='minioadmin', secret_key='minioadmin', secure=True)

इस कोड स्निपेट में, हम आवश्यक पैकेज आयात करते हैं और OPENAI_API_KEY पर्यावरण चर में संग्रहीत OpenAI API कुंजी के साथ ChatOpenAI भाषा मॉडल को आरंभ करते हैं। हम "play.min.io" सार्वजनिक सर्वर को आवश्यक कनेक्शन विवरण प्रदान करके minio_client को भी आरंभ करते हैं।

इसके बाद, आइए MinIO बकेट को परिभाषित करें और यदि यह मौजूद नहीं है तो इसे बनाएं:

 # This variable will check if bucket exists bucket_name = "test" try: # Check if bucket exists if not minio_client.bucket_exists(bucket_name): # Create the bucket because it does not exist minio_client.make_bucket(bucket_name) print(f"Bucket '{bucket_name}' created successfully.") else: print(f"Bucket '{bucket_name}' already exists.") except S3Error as err: print(f"Error encountered: {err}")

यहाँ, हम bucket_name "test" के रूप में परिभाषित करते हैं और जाँचते हैं कि क्या यह पहले से ही minio_client.bucket_exists() विधि का उपयोग करके मौजूद है। यदि बकेट मौजूद नहीं है, तो हम इसे minio_client.make_bucket() का उपयोग करके बनाते हैं। यदि बकेट पहले से मौजूद है, तो हम इसका संकेत देते हुए एक संदेश प्रिंट करते हैं। हम प्रक्रिया के दौरान होने वाली किसी भी S3Error पकड़ने और प्रिंट करने के लिए try-except ब्लॉक का उपयोग करके त्रुटि प्रबंधन भी शामिल करते हैं।

बुनियादी सेटअप के साथ, अब हम मिनियो टूल फ़ंक्शन को परिभाषित करने और एजेंट निष्पादक बनाने के लिए आगे बढ़ सकते हैं, जिसे हम अगले चरणों में कवर करेंगे।

एजेंट टूल्स के लिए LangChain के फ़ंक्शन डेकोरेटर का उपयोग करना

लैंगचेन और लैंगसर्व दोनों ही तर्क और कार्यक्षमता को समाहित करने के लिए एक समान दृष्टिकोण प्रदान करते हैं, जिससे इसे एजेंट और चेन लॉजिक में सहजता से एकीकृत किया जा सकता है। यह परिभाषित फ़ंक्शन के अंदर एक विस्तृत डॉकस्ट्रिंग के साथ @tool डेकोरेटर के उपयोग के माध्यम से प्राप्त किया जाता है, जो फ़ंक्शन को पुन: प्रयोज्य घटकों के रूप में चिह्नित करता है जिन्हें AI एजेंट द्वारा उपयोग और व्याख्या किया जा सकता है।

आइए दिए गए कोड उदाहरणों पर करीब से नज़र डालें:

 from langchain.agents import tool @tool def upload_file_to_minio(bucket_name: str, object_name: str, data_bytes: bytes): """ Uploads a file to MinIO. Parameters: bucket_name (str): The name of the bucket. object_name (str): The name of the object to create in the bucket. data_bytes (bytes): The raw bytes of the file to upload. """ data_stream = io.BytesIO(data_bytes) minio_client.put_object(bucket_name, object_name, data_stream, length=len(data_bytes)) return f"File {object_name} uploaded successfully to bucket {bucket_name}."

upload_file_to_minio फ़ंक्शन को @tool से सजाया गया है, जो दर्शाता है कि यह एक पुन: प्रयोज्य घटक है। यह किसी फ़ाइल को MinIO बकेट में अपलोड करने के लिए आवश्यक पैरामीटर लेता है, जैसे कि बकेट का नाम, ऑब्जेक्ट का नाम और फ़ाइल के कच्चे बाइट्स। फ़ंक्शन फ़ाइल अपलोड ऑपरेशन करने के लिए minio_client का उपयोग करता है और पूरा होने पर एक सफलता संदेश देता है।

 @tool def download_file_from_minio(file_info): """ Custom function to download a file from MinIO. Expects file_info dict with 'bucket_name', 'object_name', and 'save_path' keys. 'save_path' should be the local path where the file will be saved. """ bucket_name = file_info['bucket_name'] object_name = file_info['object_name'] save_path = file_info['save_path'] minio_client.get_object(bucket_name, object_name, save_path)

इसी तरह, download_file_from_minio फ़ंक्शन को भी @tool से चिह्नित किया जाता है। यह एक file_info शब्दकोश की अपेक्षा करता है जिसमें मिनियो बकेट से फ़ाइल डाउनलोड करने के लिए आवश्यक जानकारी होती है, जैसे बकेट का नाम, ऑब्जेक्ट का नाम और स्थानीय पथ जहाँ फ़ाइल को सहेजा जाना चाहिए। फ़ंक्शन निर्दिष्ट बकेट से ऑब्जेक्ट को पुनः प्राप्त करने और इसे निर्दिष्ट स्थानीय पथ पर सहेजने के लिए minio_client का उपयोग करता है।

 @tool def list_objects_in_minio_bucket(file_info): """ Custom function to list objects in a MinIO bucket. Expects file_info dict with 'bucket_name' key. Returns a list of dictionaries containing 'ObjectKey' and 'Size' keys. """ bucket_name = file_info['bucket_name'] response = minio_client.list_objects(bucket_name) return [{'ObjectKey': obj.object_name, 'Size': obj.size} for obj in response.items]

@tool से सजाए गए list_objects_in_minio_bucket फ़ंक्शन, MinIO बकेट में मौजूद ऑब्जेक्ट को सूचीबद्ध करने के लिए ज़िम्मेदार है। यह bucket_name कुंजी के साथ एक file_info शब्दकोश की अपेक्षा करता है। फ़ंक्शन निर्दिष्ट बकेट में ऑब्जेक्ट की सूची प्राप्त करने के लिए minio_client का उपयोग करता है और प्रत्येक ऑब्जेक्ट के लिए ऑब्जेक्ट कुंजी और आकार वाले शब्दकोशों की एक सूची लौटाता है।

इन कार्यात्मकताओं को उपकरणों के रूप में समाहित करके, लैंगचेन और लैंगसर्व एआई एजेंट को उन्हें अपने तर्क और निर्णय लेने की प्रक्रिया में सहजता से शामिल करने में सक्षम बनाते हैं। एजेंट अपने कार्य के आधार पर उचित उपकरण का चयन और निष्पादन बुद्धिमानी से कर सकता है, जिससे उसकी क्षमताएँ बढ़ जाती हैं और मिनियो स्टोरेज सिस्टम के साथ अधिक जटिल और गतिशील इंटरैक्शन की अनुमति मिलती है।

लैंगचेन की रननेबल विधि को समझना

लैंगचेन कस्टम लॉजिक के साथ निर्माण के लिए असंख्य तरीके प्रदान करता है, ऐसा ही एक तरीका है " रननेबल्स ". जहाँ तक उपरोक्त प्रदर्शनात्मक तर्क का सवाल है, RunnableLambda जो कि LangChain द्वारा प्रदान किया गया एक निर्माण है जो कार्यों को AI एजेंट के तर्क के भीतर निष्पादन योग्य इकाइयों के रूप में व्यवहार करने की अनुमति देता है।

 from langchain_core.runnables import RunnableLambda upload_file_runnable = RunnableLambda(upload_file_to_minio) download_file_runnable = RunnableLambda(download_file_from_minio) list_objects_runnable = RunnableLambda(list_objects_in_minio_bucket)

RunnableLambda के साथ टूल फ़ंक्शन को लपेटकर, हम रननेबल इंस्टेंस ( upload_file_runnable , download_file_runnable , और list_objects_runnable ) बनाते हैं जिन्हें एजेंट द्वारा इसके निष्पादन के दौरान बुलाया जा सकता है। ये रननेबल संबंधित टूल फ़ंक्शन को समाहित करते हैं और एजेंट को उनके साथ बातचीत करने के लिए एक समान इंटरफ़ेस प्रदान करते हैं।

 tools = [upload_file_to_minio, download_file_from_minio, list_objects_in_minio_bucket] llm_with_tools = llm.bind_tools(tools)

उपकरण सूची में मूल उपकरण फ़ंक्शन ( upload_file_to_minio , download_file_from_minio , और list_objects_in_minio_bucket ) शामिल हैं, जो एजेंट की क्षमताओं के लिए बिल्डिंग ब्लॉक के रूप में काम करते हैं llm.bind_tools(tools) लाइन उपकरणों को भाषा मॉडल ( llm ) से बांधती है, मॉडल की तर्क क्षमताओं और उपकरणों द्वारा प्रदान की गई विशिष्ट कार्यक्षमताओं के बीच एक कनेक्शन स्थापित करती है। परिणामी llm_with_tools बंधे हुए उपकरणों को नियोजित करने के ज्ञान और क्षमता के साथ संवर्धित भाषा मॉडल का प्रतिनिधित्व करता है।

RunnableLambda का उपयोग और भाषा मॉडल के लिए उपकरणों का बंधन शक्तिशाली और अनुकूलन योग्य AI एजेंट बनाने में LangChain और LangServe की लचीलापन और विस्तारशीलता को प्रदर्शित करता है। भाषा मॉडल की शक्ति को उपकरणों में समाहित विशिष्ट कार्यात्मकताओं के साथ जोड़कर, AI एजेंट जटिल कार्य करने की क्षमता प्राप्त करता है, जैसे कि MinIO पर फ़ाइलें अपलोड करना, MinIO से फ़ाइलें डाउनलोड करना और MinIO बकेट में ऑब्जेक्ट सूचीबद्ध करना।

हमारे एजेंट को मार्गदर्शन देने के लिए एक प्रॉम्प्ट टेम्पलेट लिखना

इसके बाद हम अपना ध्यान प्रॉम्प्ट टेम्पलेट पर केंद्रित करते हैं जो AI एजेंट को उपयोगकर्ता इनपुट को समझने और उस पर प्रतिक्रिया देने में मार्गदर्शन करता है। इसे ChatPromptTemplate.from_messages() विधि का उपयोग करके परिभाषित किया गया है, जो भूमिका और संदेश सामग्री वाले टपल के रूप में दर्शाए गए संदेशों की एक सूची लेता है।

 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder from langchain.agents.format_scratchpad.openai_tools import format_to_openai_tool_messages from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser from langchain_core.messages import AIMessage, HumanMessage prompt_template = ChatPromptTemplate.from_messages([ ("system", "You are a powerful assistant equipped with file management capabilities."), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ])

प्रॉम्प्ट में तीन संदेश शामिल हैं:

1. एक "सिस्टम" संदेश जो फ़ाइल प्रबंधन क्षमताओं के साथ एक शक्तिशाली सहायक के रूप में AI एजेंट के लिए संदर्भ निर्धारित करता है।

   
   

2. {input} प्लेसहोल्डर का उपयोग करके उपयोगकर्ता के इनपुट का प्रतिनिधित्व करने वाला "user" संदेश.

   
   

3. एजेंट के मध्यवर्ती चरणों और विचार प्रक्रिया को संग्रहीत करने के लिए "agent_scratchpad" नामक एक MessagesPlaceholder .

   
   

format_to_openai_tool_messages फ़ंक्शन एजेंट के स्क्रैचपैड को OpenAI के टूल्स के लिए संगत प्रारूप में स्वरूपित करता है, जबकि OpenAIToolsAgentOutputParser वर्ग मॉडल की प्रतिक्रिया को एजेंट द्वारा व्याख्या योग्य संरचित प्रारूप में पार्स करता है।

AIMessage और HumanMessage वर्ग एजेंट और उपयोगकर्ता के बीच आदान-प्रदान किए गए संदेशों का प्रतिनिधित्व करते हैं, जो एजेंट के तर्क के भीतर संचार को संभालने के लिए एक मानकीकृत तरीका प्रदान करते हैं।

प्रॉम्प्ट टेम्पलेट को परिभाषित करके, हम AI एजेंट को उपयोगकर्ता इनपुट को समझने और प्रतिक्रिया देने के लिए एक स्पष्ट संरचना और संदर्भ प्रदान करते हैं, कार्य को हल करते समय अपने मध्यवर्ती चरणों और विचार प्रक्रिया पर नज़र रखने के लिए "एजेंट_स्क्रैचपैड" प्लेसहोल्डर का उपयोग करते हैं।

एजेंट को उसके उपकरणों के साथ परिभाषित करना

अंत में, अपने agent.py पूरा करने के लिए हम अपने एजेंट को परिभाषित करते हैं और एक AgentExecutor बनाते हैं, जिसे LangServe लाइब्रेरी से add_route फ़ंक्शन का उपयोग करके server.py स्क्रिप्ट से आयात और कॉल किया जा सकता है।

हम आवश्यक घटकों को जोड़ते हैं और उन्हें एक साथ जोड़कर एकल एजेंट चर बनाते हैं।

 agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_tool_messages(x["intermediate_steps"]), } | prompt_template | llm_with_tools | OpenAIToolsAgentOutputParser() )

एजेंट को शब्दकोशों और श्रृंखलाबद्ध संचालन के संयोजन का उपयोग करके परिभाषित किया जाता है। इनपुट कुंजी आने वाले डेटा से उपयोगकर्ता इनपुट निकालती है, जबकि agent_scratchpad कुंजी format_to_openai_tool_messages फ़ंक्शन का उपयोग करके एजेंट की विचार प्रक्रिया के मध्यवर्ती चरणों को प्रारूपित करती है। एजेंट प्रॉम्प्ट टेम्पलेट ( prompt_template ), टूल के साथ भाषा मॉडल ( llm_with_tools ), और आउटपुट पार्सर ( OpenAIToolsAgentOutputParser() ) को भी शामिल करता है।

एजेंट को निष्पादित करने के लिए एजेंटएक्सीक्यूटर को परिभाषित करना

AgentExecutor बनाने के लिए, हम उसे परिभाषित एजेंट, उपलब्ध उपकरण प्रदान करते हैं, तथा विस्तृत आउटपुट के लिए verbose=True सेट करते हैं।

 from langchain.agents import tool, AgentExecutor agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

AgentExecutor कार्य को समझने और उपयोगकर्ता के इनपुट के आधार पर उपयुक्त टूल का चयन करने के लिए प्रदान किए गए एजेंट और टूल का उपयोग करता है। प्रत्येक टूल के लिए अलग-अलग प्रॉम्प्ट रखने के बजाय, एजेंट एक एकल प्रॉम्प्ट टेम्पलेट का उपयोग करता है जो उसे दिए गए इनपुट के आधार पर टूल का उपयोग करने के तरीके के बारे में मार्गदर्शन करता है। एजेंट निष्पादन प्रक्रिया के दौरान गतिशील रूप से उपयुक्त टूल का चयन करता है।

हमारे एजेंटएक्सीक्यूटर के साथ लैंगसर्व रूट को परिभाषित करना

हमारे एप्लिकेशन को LangServe के साथ एकीकृत करके सेट अप करना हमारे LangChain एप्लिकेशन को API के रूप में तैनात और प्रबंधित करने के लिए एक सुव्यवस्थित मार्ग प्रदान करता है। FastAPI को इसके प्रदर्शन और उपयोग में आसानी, एसिंक्रोनस संचालन का समर्थन करने और स्वचालित रूप से API दस्तावेज़ बनाने के लिए चुना गया है।

लैंगसर्व लाइब्रेरी , FastAPI के साथ निर्मित, REST API के रूप में LangChain ऑब्जेक्ट्स की तैनाती को सरल बनाकर इसे समृद्ध करता है, CORS सेटिंग्स के लिए अंतर्निहित मिडलवेयर प्रदान करता है ताकि यह सुनिश्चित किया जा सके कि हमारे API को विभिन्न डोमेन से सुरक्षित रूप से कॉल किया जा सके।

अधिक गहन/उपयोग-मामले प्रदर्शनों के लिए, यहां जाकर देखा जा सकता है लैंगचैन-एआई/लैंगसर्व GitHub रिपोजिटरी के अंतर्गत उदाहरण निर्देशिका .

 from fastapi import FastAPI app = FastAPI( title="MinIO Agent API", version="1.0", description="A conversational agent facilitating data storage and retrieval with MinIO", )

CORS हेडर सेट करने के लिए हम अपनी सुरक्षा बढ़ाने के लिए निम्नलिखित पंक्तियाँ जोड़ सकते हैं:

 from fastapi.middleware.cors import CORSMiddleware # Set all CORS enabled origins app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], expose_headers=["*"], )

लैंगसर्व का उपयोग करके एजेंट को क्रियान्वित करना

अब चूंकि हमने packages/agent.py काम पूरा कर लिया है, तो हम इसे आयात कर सकते हैं और अपने app/server.py स्क्रिप्ट में LangServe लाइब्रेरी से add_route फ़ंक्शन का उपयोग कर सकते हैं।

 from packages.agent import agent_executor from langserve import add_routes add_routes( app, agent_executor.with_types(input_type=Input, output_type=Output).with_config( {"run_name": "agent"} ), path=”/invoke” )

add_route(app, agent_executor(…), path="/invoke") को कॉल करके, हम अपने सर्वर एप्लिकेशन ( app ) में एक रूट जोड़ते हैं जो /invoke पथ को agent_executor() फ़ंक्शन से मैप करता है। यह एजेंट निष्पादक को तब आमंत्रित करने की अनुमति देता है जब /invoke एंडपॉइंट पर अनुरोध किया जाता है।

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

यूविकॉर्न के माध्यम से लैंगसर्व एप्लीकेशन का शुभारंभ

लैंगसर्व एप्लिकेशन को किकस्टार्ट करने के लिए, हम यूविकॉर्न को ASGI सर्वर के रूप में नियुक्त करते हैं, जो हमारे ऐप को चलाने के लिए स्टेज सेट करता है। कोड का यह स्निपेट महत्वपूर्ण है क्योंकि यह सर्वर को सक्रिय करता है, यूनिवर्सल होस्ट और एप्लिकेशन के एक्सेस पॉइंट के लिए निर्दिष्ट पोर्ट को निर्दिष्ट करता है।

 if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000)

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

सर्वर अनुप्रयोग प्रारंभ करना

उपरोक्त कोड में एक मॉड्यूलर दृष्टिकोण का प्रदर्शन किया गया है जिसमें "langchain-cli" लाइब्रेरी का उपयोग करना, एक नया langchain ऐप बनाना और चेन लॉजिक को agent.py में सहेजना शामिल है जबकि FastAPI और LangServe कार्यान्वयन को server.py में सहेजा गया है।

यह हमारा अंतिम चरण है, हम अपने एप्लिकेशन के निर्माण के प्रदर्शनात्मक उद्देश्य के लिए अपने एप्लिकेशन कोड को server.py में सहेज लेंगे।

हमारी सेवा चलाने का सबसे सरल तरीका यह है:

 python server.py

यह कमांड एप्लिकेशन को चलाएगा, तथा ऐसे लॉग या त्रुटि संदेश लौटाएगा जिन्हें अभी भी डीबग करने की आवश्यकता है।

लैंगसर्व खेल का मैदान

पायथन आउटपुट में LangServe लॉग /invoke/playground एप्लिकेशन एंडपॉइंट के रूप में पहचानते हैं। अब हम अपने API के लिए प्लेग्राउंड वेबयूआई के साथ-साथ स्वचालित दस्तावेज़ भी देख सकते हैं जो हमारे API के /docs पथ पर जाकर उपलब्ध है; यह हमें हमारे प्रत्येक एप्लिकेशन फीचर के लिए इसे आज़माएँ बटन के साथ-साथ पूर्वनिर्धारित cURL अनुरोधों को शामिल करके परीक्षण और कॉन्फ़िगर करने के लिए एक सरल दृष्टिकोण प्रदान करता है जिसे हम वेबयूआई से निष्पादित कर सकते हैं।

परिणामस्वरूप, हमारा मिनियो-एकीकृत लैंगचेन एजेंट अब कुशलतापूर्वक एक परिनियोजन योग्य एपीआई में परिवर्तित हो गया है, जो बैच प्रोसेसिंग से लेकर वास्तविक समय की अंतःक्रियाओं तक की कार्यक्षमताओं के साथ उपयोगकर्ताओं के लिए विकसित और विस्तारित होने के लिए तैयार है।

लैंगसर्व एपीआई का आगे उपयोग

Langserve एप्लिकेशन के चालू होने पर हम इसे अपने server.py के बाहर से, अपने समापन बिंदु को लक्षित करके और इसे Langserve के RemoteRunnable मॉड्यूल में लपेटकर उपयोग कर सकते हैं:

 from langserve import RemoteRunnable remote_runnable = RemoteRunnable("http://localhost:8000/<path>/")

जोड़ना

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

लैंगसर्व के साथ एआई पाइपलाइनों का विकास

लैंगसर्व न केवल लैंगचेन एप्लीकेशन को तैनात करने की प्रक्रिया को सरल बनाता है, बल्कि इसे काफी सरल भी बनाता है। विकास और तैनाती के बीच की खाई को पाटकर, यह सुनिश्चित करता है कि मिनियो और लैंगचेन का लाभ उठाने वाले अभिनव एप्लीकेशन अवधारणा से वास्तविकता में तेजी से आगे बढ़ सकते हैं, व्यापक पारिस्थितिकी तंत्र में एकीकृत होने और उपयोगकर्ता के अनुभवों को बढ़ाने के लिए तैयार हो सकते हैं।

हमारे अन्वेषणों में शामिल विकास के माध्यम से, हमने MinIO के साथ सहज एकीकरण देखा है लैंगचेन यह बिल्कुल संभव है, और कैसे लैंगसर्व इन उन्नत समाधानों को लागू करने में महत्वपूर्ण भूमिका निभाता है। जैसे-जैसे हम AI और ML के विकसित होते परिदृश्य को नेविगेट करना जारी रखते हैं, LangServe जैसे उपकरण एप्लिकेशन विकास के क्षेत्र में अत्याधुनिक तकनीकों को सबसे आगे लाने में सहायक बने रहेंगे।

मिनियो में, हम इस तकनीक-समृद्ध युग के दौरान डेवलपर समुदाय के भीतर रचनात्मकता और क्षमता से उत्साहित हैं। सहयोग और ज्ञान के आदान-प्रदान के लिए इससे बेहतर समय नहीं हो सकता। हम आपसे जुड़ने के लिए उत्सुक हैं! हमारे साथ जुड़ें मिनियो स्लैक बातचीत जारी रखने और एक साथ नई ऊंचाइयों तक पहुंचने के लिए एक चैनल की आवश्यकता है।