Cohere Command R+: एक संपूर्ण चरण-दर-चरण ट्यूटोरियल

क्या आप एक हैंड्स-ऑन प्रोजेक्ट के साथ अपनी AI जानकारी बढ़ाना चाहते हैं? इस ट्यूटोरियल में, हम Cohere Command R+ को एक्सप्लोर करेंगे, जिसमें इसे ऑनलाइन और लोकली एक्सेस करने के तरीके शामिल हैं। हम Cohere Python API की प्रमुख खूबियों में भी गहराई से जाएंगे और LangChain और Tavily का उपयोग करके एक AI प्रोजेक्ट बनाएंगे।

रोमांचक हिस्सा प्रोजेक्ट से शुरू होता है। यदि आप पहले से Cohere मॉडल्स और उनकी खूबियों से परिचित हैं, तो बेझिझक सीधे प्रोजेक्ट सेक्शन पर जाएँ। वहाँ, आप सीखेंगे कि कैसे एक AI एजेंट बनाएं जो किसी कार्य को पूरा करने के लिए क्रम में कई टूल्स का उपयोग करता है।

यदि आप AI में नए हैं और इस क्षेत्र के बारे में अधिक सीखना चाहते हैं, तो AI Fundamentals ट्रैक पर विचार करें। आप ChatGPT, Large Language Models (LLMs), जनरेटिव AI और अन्य लोकप्रिय AI विषयों पर कारगर ज्ञान हासिल करेंगे।

Cohere Command R+ क्या है?

Command R+ Cohere का नवीनतम और अत्याधुनिक LLM है। यह मॉडल संवादात्मक इंटरैक्शन और लंबी संदर्भ-लंबाई वाले कार्यों में उत्कृष्ट है। यह विशेष रूप से जटिल Retrieval Augmented Generation (RAG) वर्कफ़्लोज़ और मल्टी-स्टेप टूल उपयोग के लिए ऑप्टिमाइज़ किया गया है, जिससे यह एंटरप्राइज़-स्तरीय ऐप्लिकेशंस के लिए एक शक्तिशाली टूल बनता है।

छवि: लेखक द्वारा

Cohere Command R+ की प्रमुख खूबियाँ

ये Command R+ मॉडल की कुछ सबसे प्रासंगिक खूबियाँ हैं।

• लंबा संदर्भ-लंबाई: यह मॉडल लंबी संदर्भ-लंबाई (अधिकतम 128k टोकन) और 4k टोकन के अधिकतम आउटपुट के साथ, पिछले मॉडलों की तुलना में उच्च गुणवत्ता और अधिक विश्वसनीयता से भाषा कार्य करता है।
• बहुभाषी क्षमता: Command R+ को कई भाषाओं के विविध कॉर्पस पर प्रशिक्षित किया गया है, जिससे यह विभिन्न टेक्स्ट-जनरेशन कार्य कर सकता है। यह अंग्रेज़ी, फ़्रेंच, स्पेनिश, इतालवी, जर्मन और अन्य भाषाओं के लिए ऑप्टिमाइज़ किया गया है. 
• क्रॉस-लिंगुअल क्षमता: मॉडल अनुवाद या प्रश्नों के उत्तर देने जैसे क्रॉस-लिंगुअल कार्य कर सकता है।
• रिट्रीवल ऑगमेंटेड जनरेशन: Command R+ के साथ RAG करने के लिए आपको LangChain या अन्य AI फ़्रेमवर्क की आवश्यकता नहीं है। बस चैट फ़ंक्शन को अतिरिक्त दस्तावेज़ दें, और यह स्रोत दर्शाने वाले संदर्भों के साथ संदर्भ-संगत उत्तर जनरेट करेगा. 
• मल्टी-स्टेप टूल उपयोग: मॉडल को किसी सर्च इंजन टूल से कनेक्ट करें या डेटाबेस और APIs से कनेक्ट करने के लिए अपना टूल बनाएँ। इससे मॉडल कई बाहरी स्रोतों से संवाद कर सकता है और क्वेरी के अनुरूप, अद्यतन उत्तर जनरेट कर सकता है.  

Cohere मॉडलों की गहन समझ के लिए, Cohere API Tutorial: Cohere Models के साथ शुरुआत करें अवश्य पढ़ें।

Cohere Command R+ को कैसे एक्सेस करें

Cohere मॉडल्स तक पहुँचने के अलग-अलग तरीके हैं, जिनमें से अधिकतर निःशुल्क हैं. 

आप ऑनलाइन LLM प्लेग्राउंड एक्सेस कर सकते हैं या मॉडल को लोकली डाउनलोड करके किसी चैट ऐप्लिकेशन के साथ उपयोग कर सकते हैं। इसके अलावा, आप Cohere API के माध्यम से भी इसे एक्सेस कर सकते हैं। आइए इन प्रत्येक तरीकों की समीक्षा करें।

Cohere Command R+ को ऑनलाइन उपयोग करना

Cohere Command R+ को ऑनलाइन एक्सेस करने का सबसे सरल तरीका HuggingChat वेबसाइट है। इसमें कोई सीमाएँ नहीं हैं, और आप इसे छवि जनरेशन या इंटरनेट सर्च जैसे अलग-अलग कार्यों के लिए उपलब्ध छह टूल्स से भी कनेक्ट कर सकते हैं।

1. https://huggingface.co/chat/ वेबसाइट पर जाएँ।

2. बाएँ पैनल पर, मॉडल के मेनू तक पहुँचने के लिए “Models” बटन पर क्लिक करें, फिर “c4ai-command-r-plus” मॉडल चुनें।

Hugging Chat में मॉडल्स डायरेक्टरी। छवि स्रोत: HuggingChat

3. क्वेरी लिखना शुरू करें, और यह तेज़ व अत्यंत सटीक उत्तर जनरेट करेगा।

Hugging Chat में प्रॉम्प्टिंग। छवि स्रोत: HuggingChat

Cohere Command R+ को लोकली उपयोग करना

आप Command R+ को लोकली दो तरीकों से उपयोग कर सकते हैं: मॉडल को अपने लोकल मशीन पर डाउनलोड करके, या Jan चैट ऐप्लिकेशन को API कुंजी प्रदान करके. 

आइए दूसरे विकल्प को एक्सप्लोर करते हैं।

1. Jan को डाउनलोड और इंस्टॉल करें, वेबसाइट: https://jan.ai/.

2. बाएँ पैनल पर विंडोज़ बटन पर क्लिक करके मॉडल हब पर जाएँ।

Jan ऐप्लिकेशन में मॉडल डायरेक्टरी

3. Command R+ मॉडल तक पहुँचने के लिए, मॉडल हब सर्च बार में “pmysl/c4ai-command-r-plus-GGUF ” टाइप करें।

• ध्यान दें कि Command R+ मॉडल डाउनलोड करने के लिए आपके सिस्टम में 30GB से अधिक RAM होनी चाहिए।

4. मॉडल के “Q4_K_M version” को डाउनलोड करें और उपयोग शुरू करें, जिसका साइज़ लगभग 31.24GB है।

Hugging Face से मॉडल इम्पोर्ट करना 

API के माध्यम से Cohere Command R+ का उपयोग

Command R+ मॉडल को लोकली उपयोग करने का एक और तरीका है Cohere API को Jan ऐप्लिकेशन से जोड़ना. 

1. https://coral.cohere.com/ वेबसाइट पर जाएँ और साइन इन करें. 

2. “Dashboard” पर जाएँ।

3. बाएँ पैनल पर “API keys” बटन पर क्लिक करें, फिर नीचे स्क्रॉल करें और “+ Create Trail key.” पर क्लिक करें।

Cohere ट्रायल API key जनरेट करना। स्रोत: cohere.com

4. Cohere API key जनरेट करने के बाद, इसे “Model Provider” सेक्शन में पेस्ट करें। आप इस मेनू तक “Settings” में जाकर और “Cohere” देखकर पहुँच सकते हैं।

Jan ऐप्लिकेशन में Cohere API key जोड़ना

5. “Thread” मेनू में जाएँ और दाएँ पैनल पर उपयुक्त मॉडल चुनकर Command R+ मॉडल का चयन करें।

Jan ऐप्लिकेशन में मॉडल चुनना

6. प्रॉम्प्टिंग शुरू करें और सुनिश्चित करें कि आप इसे “Stream” सक्षम करके उपयोग कर रहे हैं।

Jan ऐप्लिकेशन में Cohere Command R plus का उपयोग

Cohere Python API के साथ शुरुआत

इस सेक्शन में, आप रिस्पॉन्स जनरेट करने के लिए Python API को सेटअप और उपयोग करना सीखेंगे।

1. pip का उपयोग करके Cohere Python पैकेज इंस्टॉल करें।

pip install cohereसंचालित द्वारा

2. एक नई Cohere API key जनरेट करें। आप “API के माध्यम से Cohere Command R+ का उपयोग” सेक्शन के चरणों का पालन कर सकते हैं।

Cohere ट्रायल API key जनरेट करना। छवि स्रोत: cohere.com

3. हम अपने डेवलपमेंट एनवायरनमेंट के रूप में DataCamp के DataLab का उपयोग करेंगे। DataLab में environment variables सेट करने के लिए ये चरण अपनाएँ:

1. 1. DataLab पर जाएँ और नया नोटबुक बनाएँ। आप निःशुल्क शुरुआत कर सकते हैं।
   2. नोटबुक बनने के बाद, आप इसे अपनी इच्छानुसार नाम दे सकते हैं।
   3. “Environment” टैब पर जाएँ, “Environment variables” चुनें और “+ Add to add new environment variables” पर क्लिक करें।
   4. “COHERE_API_KEY” नाम से नया environment variable जोड़ें और वैल्यू के रूप में अपनी नई बनी Cohere API key जोड़ें। सेट का नाम “Cohere” जोड़ सकते हैं।

 DataLab में Environment variables जोड़ना

4. DataCamp के DataLab में environment variable सक्रिय करने के लिए, environment variable मेनू में जाएँ, “Cohere” के बगल में तीन बिंदुओं पर क्लिक करें और फिर “Connect” पर क्लिक करें।

DataLab में Cohere environment variable कनेक्ट करना

5. अब, अपने नोटबुक में, API key प्रदान करके Cohere क्लाइंट आरंभ करें। यह Cohere लाइब्रेरी इम्पोर्ट करके और अपनी API key के साथ एक क्लाइंट ऑब्जेक्ट बनाकर किया जा सकता है।

import os
import cohere

cohere_api_key = os.environ["COHERE_API_KEY"]
co = cohere.Client(api_key=cohere_api_key)संचालित द्वारा

6. .chat() फंक्शन का उपयोग करके रिस्पॉन्स जनरेट करने के लिए, model का नाम और message प्रदान करें।

response = co.chat(
  model="command-r-plus",
  message="Please help me write an email to the angry boss, who thinks I made the changes to the data pipeline but didn't. It was James."
)

print(response.text) संचालित द्वारा

दिए गए प्रश्न पर मॉडल का उत्तर

रिस्पॉन्स जनरेशन तेज़ और अत्यंत प्रासंगिक होना चाहिए! 

अगले सेक्शन में, हम Cohere Python API की विभिन्न खूबियों का अन्वेषण करेंगे. 

Command R+ Python API की प्रमुख खूबियों का अन्वेषण

अब, हम Cohere Python API का अन्वेषण करेंगे ताकि हिस्ट्री के साथ रिस्पॉन्स जनरेट कर सकें, स्ट्रीम रिस्पॉन्स प्राप्त कर सकें और पूर्वानुमानित आउटपुट ले सकें। हम RAG भी करेंगे, टेक्स्ट को embeddings में बदलेंगे, और कस्टम डेटासेट पर मॉडल को फाइन-ट्यून करेंगे।

टेक्स्ट जनरेशन

पिछले सेक्शन में, हमने साधारण .chat() फंक्शन का उपयोग करके रिस्पॉन्स जनरेट करना सीखा। अब, हम इसमें सिस्टम प्रॉम्प्ट (preamble), chat_history, max_tokens, और temperature जैसे अतिरिक्त आर्ग्युमेंट्स देंगे।

response = co.chat(
    model="command-r-plus",
    preamble="You are a happy chatbot that puts a positive spin on everything.",
    chat_history=[
       {"role": "USER", "text": "Hey, my name is Abid!"},
       {"role": "CHATBOT", "text": "Hey Abid! How can I help you today?"},
    ],
    message="I can't swim?",
    max_tokens=150,
    temperature=0.7
)

print(response.text)संचालित द्वारा

दिए गए अतिरिक्त आर्ग्युमेंट्स के साथ मॉडल का उत्तर

अतिरिक्त आर्ग्युमेंट्स के आधार पर, मॉडल ने अपने उत्तर को संशोधित किया है।

स्ट्रीमिंग

हम .chat_stream() फंक्शन का उपयोग करके रिस्पॉन्स को स्ट्रीम भी कर सकते हैं। यह फंक्शन रियल टाइम में टोकन उपलब्ध होते ही उन्हें जनरेट करता है, जिससे मॉडल की perceived स्पीड बढ़ती है।

response = co.chat_stream(
    model="command-r-plus",
    message="Tell me something interesting about the galaxy?"
)

for event in response:
    if event.event_type == "text-generation":
      print(event.text, end="")
    elif event.event_type == "stream-end":
      print(event.finish_reason, end="")संचालित द्वारा

मॉडल रियल टाइम में टोकन लौटाता हुआ

पूर्वानुमानित आउटपुट

पूर्वानुमानित आउटपुट Cohere की एक विशिष्ट खूबियों में से है। seed आर्ग्युमेंट सेट करके, हम मॉडल को एक ही प्रॉम्प्ट पर हमेशा एक जैसा रिस्पॉन्स जनरेट करने के लिए कह सकते हैं।

आम तौर पर, जब आप किसी LLM से एक ही सवाल दो बार पूछते हैं, तो आपको अलग-अलग उत्तर मिलते हैं। seed सेट करने से लगातार और पुनरुत्पाद्य परिणाम सुनिश्चित होते हैं, ठीक किसी भी मशीन लर्निंग मॉडल की तरह।

निम्न उदाहरण में, seed आर्ग्युमेंट को 55 पर सेट करने से, आपको हमेशा "Matilda" उत्तर मिलेगा।

res = co.chat(model="command-r", message="say a random name", seed=55)
print(res.text)संचालित द्वारा

Sure! I will pick a random name for you. How about "Matilda"?संचालित द्वारा

हमारे सिद्धांत की जाँच करने के लिए, हमने फिर से उसी seed के साथ मॉडल से वही प्रश्न पूछा है. 

res = co.chat(model="command-r", message="say a random name", seed=55)
print(res.text)संचालित द्वारा

Sure! I will pick a random name for you. How about "Matilda"?संचालित द्वारा

और इसने वही परिणाम उत्पन्न किया!

रिट्रीवल ऑगमेंटेड जनरेशन (RAG)

Cohere API RAG करने के लिए एक बिल्ट-इन फंक्शन प्रदान करता है। हमें बस .chat() फंक्शन को documents आर्ग्युमेंट देना है। प्रश्न पूछने पर, यह दस्तावेज़ों पर समानता खोज चलाकर संदर्भ-संगत उत्तर जनरेट करेगा।

हम उदाहरण के तौर पर एनीमे रिसर्च दस्तावेज़ों का उपयोग करेंगे। दस्तावेज़ों का फ़ॉर्मेट नीचे दिए गए उदाहरण जैसा होना चाहिए। प्रत्येक दस्तावेज़ में title और snippet keys होने चाहिए।

anime = [
    {
        "title": "Naruto Popularity Analysis",
        "snippet": "Naruto's global success: massive manga sales, top anime ratings, extensive merchandise, and a dedicated fanbase. The series' impact on anime culture and its influence on subsequent shonen series is undeniable."
    },
    {
        "title": "One Piece Popularity Analysis",
        "snippet": "One Piece's record-breaking manga sales and its status as a long-running anime phenomenon highlight its popularity. The series' captivating story and characters have made it a staple in the anime community."
    },
    {
        "title": "Attack on Titan Popularity Analysis",
        "snippet": "Attack on Titan's intense storyline and high-quality animation have garnered a massive following. Its success in both manga and anime formats demonstrates its widespread appeal."
    },
    {
        "title": "My Hero Academia Popularity Analysis",
        "snippet": "My Hero Academia's rapid rise to fame is marked by its engaging characters and compelling plot. The series has achieved impressive manga sales and anime viewership."
    }
]
संचालित द्वारा

सटीक और संदर्भपूर्ण उत्तर जनरेट करने के लिए, हम anime दस्तावेज़ों को documents आर्ग्युमेंट के रूप में .chat() फंक्शन को देंगे।

response = co.chat(
    model="command-r-plus",
    message="Which Anime series have most engaging characters?",
    documents=anime,
)

print(response.text) संचालित द्वारा

Some anime series with engaging characters include My Hero Academia and One Piece.संचालित द्वारा

जैसा कि आप देख सकते हैं, मॉडल दस्तावेज़ों का उपयोग करके अत्यधिक सटीक उत्तर जनरेट करता है।

यदि आप जानना चाहते हैं कि बैकग्राउंड में क्या हो रहा है और मॉडल कैसे उत्तर जनरेट करता है, तो आप बस मेटाडेटा सहित पूरे response को प्रिंट कर सकते हैं।

responseसंचालित द्वारा

ध्यान दें ChatCitation हिस्से पर और कैसे Cohere का .chat() फंक्शन ने दस्तावेज़ों के स्निपेट्स का उपयोग करके रिस्पॉन्स जनरेट किया है. 

हम .chat() फंक्शन से टूल्स और कनेक्टर्स भी जोड़ सकते हैं। निम्न उदाहरण में, हम मॉडल से एक इंटरनेट सर्च इंजन कनेक्ट करते हैं ताकि अद्यतन उत्तर जनरेट हो सके।

response = co.chat(
    model="command-r-plus",
    message="Which Anime series have most engaging characters?",
    connectors=[{"id": "web-search"}],
)

print(response.text) संचालित द्वारा

Here are some Anime series with engaging characters:
- Jujutsu Kaisen
- One Piece
- Naruto
- Dragon Ball Z
- Bleach
- Death Note
- Fullmetal Alchemist: Brotherhood
- Demon Slayer: Kimetsu no Yaiba
- Attack on Titan
- Mob Psycho 100
- Trigun
- My Hero Academia
- Cowboy Bebop
- Komi Can't Communicate
- Spy X Familyसंचालित द्वारा

इस मामले में, मॉडल इंटरनेट पर जानकारी खोजता है और फिर मॉडल को संदर्भ प्रदान करता है ताकि अद्यतन और सटीक परिणाम जनरेट हो सकें।

प्रभावी सूचना पुनर्प्राप्ति तंत्रों के साथ LLMs की ताकतों के बारे में अधिक जानने के लिए, ट्यूटोरियल Boost LLM Accuracy with Retrieval Augmented Generation (RAG) and Reranking का अनुसरण करें।

एम्बेडिंग्स

टेक्स्ट एम्बेडिंग्स टेक्स्ट के संख्यात्मक प्रतिनिधित्व हैं जो अर्थ-साम्य (semantic meaning) को कैप्चर करते हैं, जिससे समानता खोज और पाठ्य डेटा के विश्लेषण को कुशल बनाया जा सकता है. 

Cohere के .embed() फंक्शन के साथ, हम सर्च क्वेरीज के लिए टेक्स्ट को एम्बेडिंग वेक्टर्स में बदल सकते हैं। हमें बस फंक्शन को model का नाम, texts की सूची, input_type और embedding_types प्रदान करने हैं।

texts = [ 'I love you', 'I hate you', 'Who are you?']  

response = co.embed(
  model='embed-english-v3.0',
  texts=texts, 
  input_type='search_query',
  embedding_types=['float']) 


embeddings = response.embeddings.float # All text embeddings 
print(embeddings[2][:5]) 
संचालित द्वारा

[-0.00459671, -0.010803223, -0.048339844, -0.012306213, -0.019134521]संचालित द्वारा

Cohere हमें बहुभाषी टेक्स्ट को भी एम्बेडिंग्स में बदलने देता है। ऐसा करने के लिए, हमें एम्बेडिंग मॉडल को “embed-multilingual-v3.0” में बदलना होगा और input_type को “classification” पर सेट करना होगा।

texts = [  
   'I love you', 'Te quiero', 'Ich liebe dich',  
   'Ti amo', 'Я тебя люблю', ' 我爱你 ',  
   '愛してる', 'أحبك', 'मैं तुमसे प्यार करता हूँ'  
]  

response = co.embed(
  model='embed-multilingual-v3.0',
  texts=texts, 
  input_type='classification',
  embedding_types=['float']) 

embeddings = response.embeddings.float # All text embeddings 
print(embeddings[2][:5]) संचालित द्वारा

[-0.011756897, 0.0116119385, -0.005115509, 0.011657715, -0.001660347]संचालित द्वारा

फाइन-ट्यूनिंग

OpenAI API की तरह, Cohere API हमें कस्टम डेटासेट पर मॉडल को फाइन-ट्यून करने देता है। ऐसा करने के लिए, हम डेटा अपलोड करते हैं और फाइन-ट्यूनिंग फंक्शन चलाते हैं। यह उतना ही सरल है. 

अपने उदाहरण के लिए, हम ChatGPT (GPT-4o) मॉडल का उपयोग करके दो कस्टम डेटासेट जनरेट करेंगे। नीचे दिखाए गए डेटासेट फ़ॉर्मेट का पालन करें।

जेनरेट किए गए डेटा का उपयोग करके “positive_bot_train” और “positive_bot_eval” JSONL फाइलें बनाएँ और .datasets.create() फंक्शन को फाइल लोकेशन प्रदान करें। फंक्शन को डेटासेट का name और फाइन-ट्यूनिंग का type भी चाहिए।

my_dataset = co.datasets.create(
  name="Happy assistant",
  type="chat-finetune-input",
  data=open("./data/positive_bot_train.jsonl", "rb"),
  eval_data=open("./data/positive_bot_eval.jsonl", "rb")
)

result = co.wait(my_dataset)
print(result)संचालित द्वारा

जैसा कि हम देख सकते हैं, फंक्शन ने डेटासेट को वैलिडेट कर लिया है और उसे Cohere क्लाउड स्टोरेज पर अपलोड कर दिया है।

अब, हमें क्लाउड में फाइन-ट्यूनिंग प्रक्रिया शुरू करने के लिए मॉडल का name, base_type, और dataset_id को .finetuning.create_finetuned_model() फंक्शन को देना होगा. 

from cohere.finetuning import FinetunedModel, Settings, BaseModel

# start training a custom model using the dataset
finetuned_model = co.finetuning.create_finetuned_model(
  request=FinetunedModel(
    name="happy-chat-bot-model",
    settings=Settings(
      base_model=BaseModel(
        base_type="BASE_TYPE_CHAT",
      ),
      dataset_id=my_dataset.id,
    ),
  ),
)संचालित द्वारा

मॉडल फाइन-ट्यूनिंग की प्रगति देखने के लिए, Cohere डैशबोर्ड पर जाएँ और बाएँ पैनल पर “Fine-tuning” विकल्प पर क्लिक करें. 

फाइन-ट्यूनिंग स्थिति। स्रोत: Models | Cohere

मॉडल को फाइन-ट्यून करने और इवैल्युएशन रिपोर्ट जनरेट होने में कुछ मिनट लग सकते हैं।

फाइन-ट्यूनिंग परिणाम। छवि स्रोत: Fine-tuned Model - happy-chat-bot-model | Cohere

मॉडल फाइन-ट्यून होने के बाद, हमें परिणामों का एक ओवरव्यू मिलता है। जैसा कि आप ऊपर की छवि में देख सकते हैं, मॉडल की सटीकता काफ़ी कम है। क्यों? हमने इसे केवल दो-पंक्ति वाला डेटासेट दिया है। सटीकता बढ़ाने के लिए, कम से कम 1000 पंक्तियों वाले वास्तविक-विश्व डेटा प्रदान करने का प्रयास करें।

अपने फाइन-ट्यून किए गए मॉडल तक पहुँचने के लिए, हम .chat() फंक्शन को मॉडल ID के साथ, preamble, message, और max_tokens के साथ प्रदान कर सकते हैं।

मॉडल ID आप डैशबोर्ड पर जाकर, “Fine-tuning” विकल्प चुनकर, फिर "YOUR MODELS" में जाकर और फाइन-ट्यून किए गए मॉडलों की सूची से मॉडल ID कॉपी करके पा सकते हैं।

response = co.chat(
    model="8f34d596-b94e-4395-afad-1db35b2b0b53-ft",
    preamble="You are a happy chatbot that puts a positive spin on everything.",
    message="I burned my finger while barbecuing.",
    max_tokens=100
)

print(response.text)
संचालित द्वारा

Ouch! That doesn't sound fun, but it's great that you're taking time to relax and enjoy some delicious grilled foods. Barbecuing is a wonderful way to spend time with friends and family, and it's an excellent opportunity to savor the little things in life. Remember to take care of your burn; it's a small price to pay for a fun day making delicious memories!संचालित द्वारा

जेनरेट किया गया रिस्पॉन्स बुरा नहीं है!

Command R+ का उपयोग करके AI प्रोजेक्ट बनाना

अब हम LangChain इकोसिस्टम और Cohere Command R+ मॉडल का उपयोग करके एक मल्टी-स्टेप AI एजेंट बनाएँगे।

यह AI ऐप्लिकेशन उपयोगकर्ता की क्वेरी लेकर Tavily API का उपयोग करके वेब पर सर्च करेगा और Python कोड जनरेट करेगा। फिर, यह Python REPL का उपयोग करके कोड को निष्पादित करेगा और वह विज़ुअलाइज़ेशन लौटाएगा जो उपयोगकर्ता ने अनुरोध किया है।

1. Python पैकेज इंस्टॉल करना

पहले, हमें सभी आवश्यक Python पैकेज इंस्टॉल करने की ज़रूरत है। हम इसे DataLab नोटबुक में कर सकते हैं।

%pip install --quiet langchain langchain_cohere langchain_experimentalसंचालित द्वारा

2. Cohere चैट मॉडल सेट करना

इसके बाद, हम LangChain Python API का उपयोग करके पहले बनाई Cohere API key प्रदान करके एक चैट क्लाइंट बनाते हैं। हम AI एजेंट में भाषा मॉडल के रूप में Command R+ का उपयोग करेंगे. 

import os
from langchain_cohere.chat_models import ChatCohere

cohere_api_key = os.environ["COHERE_API_KEY"]
chat = ChatCohere(model="command-r-plus", temperature=0.7, api_key=cohere_api_key)संचालित द्वारा

3. इंटरनेट सर्च के लिए Tavily सेट करना

Tavily पर साइन अप करें और अपनी API key कॉपी करें। Tavily LLMs और RAG पाइपलाइनों के लिए एक इंटरनेट सर्च API है।

Tavily API key जनरेट करना। छवि स्रोत: Tavily AI

इंटरनेट सर्च टूल बनाने के लिए, हाल ही में जेनरेट की गई API key को DataLab में environment variable के रूप में प्रदान करें। फिर name, description और args_schema अपडेट करें।

from langchain_community.tools.tavily_search import TavilySearchResults

internet_search = TavilySearchResults(api_key=os.environ['TAVILY_API_KEY'])
internet_search.name = "internet_search"
internet_search.description = "Returns a list of relevant documents from the internet."

from langchain_core.pydantic_v1 import BaseModel, Field

class TavilySearchInput(BaseModel):
    query: str = Field(description="Internet query engine.")

internet_search.args_schema = TavilySearchInputसंचालित द्वारा

4. Python REPL सेट करना

Python REPL टूल बनाना सीधा-सादा है: Tool क्लास को एक Python REPL ऑब्जेक्ट, name और description दें, और नीचे दिखाए अनुसार आर्ग्युमेंट स्कीमा संशोधित करें।

from langchain.agents import Tool
from langchain_experimental.utilities import PythonREPL

python_repl = PythonREPL()
repl_tool = Tool(
    name="python_repl",
    description="Executes python code and returns the result.",
    func=python_repl.run,
)
repl_tool.name = "python_interpreter"

class ToolInput(BaseModel):
    code: str = Field(description="Python code execution.")

repl_tool.args_schema = ToolInputसंचालित द्वारा

5. AI एजेंट बनाना और चलाना

अब, हम .create_cohere_react_agent() फंक्शन, Cohere मॉडल क्लाइंट, टूल्स, और प्रॉम्प्ट टेम्पलेट का उपयोग करके सब कुछ मिलाकर मल्टी-स्टेप AI एजेंट बनाएँगे। हमारे AI एजेंट को चलाने के लिए, हम AgentExecutor क्लास का उपयोग करेंगे और इसे एजेंट ऑब्जेक्ट व टूल्स प्रदान करेंगे।

from langchain.agents import AgentExecutor
from langchain_cohere.react_multi_hop.agent import create_cohere_react_agent
from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_template("{input}")

agent = create_cohere_react_agent(
    llm=chat,
    tools=[internet_search, repl_tool],
    prompt=prompt,
)

agent_executor = AgentExecutor(agent=agent, tools=[internet_search, repl_tool], verbose=True)संचालित द्वारा

6. एजेंट का परीक्षण

फिर, agent_executor का उपयोग करके विज़ुअलाइज़ेशन जनरेट करें। हमारे मामले में, हमने AI एजेंट से इंटरनेट से नवीनतम डेटा एकत्र करने और एक पाई चार्ट बनाने के लिए कहा।

response = agent_executor.invoke({
    "input": "Create a pie chart of the top 5 most used programming languages in 2024.",
})संचालित द्वारा

Cohere मॉडल द्वारा बनाया गया शीर्ष प्रोग्रामिंग भाषाओं का पाई चार्ट। छवि: लेखक द्वारा

परिणाम कमाल का है! इसने इंटरनेट के नवीनतम डेटा का उपयोग करके सफलतापूर्वक पाई चार्ट जनरेट कर दिया।

यदि आपको इस ट्यूटोरियल में दिए गए कोड को चलाने में समस्या आ रही है, तो DataLab वर्कस्पेस Cohere Command R+ Tutorial देखें, जिसमें कोड स्रोत, डेटासेट और आउटपुट्स शामिल हैं।

LangChain की तरह, आप LlamaIndex का उपयोग करके भी मल्टी-स्टेप AI एजेंट बना सकते हैं। LlamaIndex के साथ शुरुआत करने के लिए, Retrieval Augmented Generation with LlamaIndex वीडियो ट्यूटोरियल देखें।

निष्कर्ष

AI बाज़ार फिर से गर्म हो रहा है, और नए टूल्स व APIs सीखना आपको बेहतर AI सिस्टम बनाने और अपना पोर्टफोलियो मजबूत करने में मदद करेगा। साथ ही, यह आपके वर्कफ़्लो को सरल बनाएगा, क्योंकि कुछ AI फ़्रेमवर्क आपके लिए अधिकतर कार्य संभाल लेते हैं और आपको केवल कुछ पंक्तियों का कोड लिखना पड़ता है।

इस ट्यूटोरियल में, हमने Cohere Command R+ मॉडल के बारे में सीखा और इसे Hugging Face चैट, Jan ऐप्लिकेशन और API का उपयोग करके कैसे एक्सेस करें, यह जाना। हमने Python API के बारे में भी सीखा और कस्टम रिस्पॉन्स जनरेट करने के लिए मॉडल को कैसे फाइन-ट्यून करें, यह देखा। अंत में, हमने एक सक्षम AI एजेंट बनाया जो उपयोगकर्ता की क्वेरियाँ लेता है, इंटरनेट से नवीनतम डेटा खोजता है, और Python REPL का उपयोग करके विज़ुअलाइज़ेशन जनरेट करता है।

LLMs की शक्ति के बारे में और अधिक सीखने के लिए, साथ ही प्रॉम्प्ट्स से कंटेंट जनरेट करने, दस्तावेज़ों से जानकारी निकालने, और एक सेमांटिक सर्च इंजन बनाने के तरीकों के लिए, हमारे कोड-अलॉन्ग वीडियो सेशन using Large Language Models with the Cohere API देखें।