इस लेख में, हम सीखेंगे कि एक कस्टम एजेंट कैसे बनाया जाए जो एक ओपन सोर्स एलएलएम (llama3.1) का उपयोग करता है जो हमारे पीसी पर स्थानीय रूप से चलता है। हम ओलामा और लैंगचेन का भी उपयोग करेंगे।

रूपरेखा

• ओलामा स्थापित करें
• मॉडल खींचो
• सर्व मॉडल
• एक नया फ़ोल्डर बनाएं, इसे एक कोड संपादक के साथ खोलें
• आभासी वातावरण बनाएं और सक्रिय करें
• लैंगचेन स्थापित करें लैंगचैन-ओलामा
• पायथन में ओपन सोर्स मॉडल के साथ कस्टम एजेंट बनाएं
• निष्कर्ष

ओलामा स्थापित करें

ओलामा को स्थापित करने के लिए इसके GitHub README में अपने OS प्रकार के आधार पर निर्देशों का पालन करें:

https://github.com/ollama/ollama

मैं लिनक्स-आधारित पीसी पर हूं, इसलिए मैं अपने टर्मिनल में निम्नलिखित कमांड चलाने जा रहा हूं:

curl -fsSL https://ollama.com/install.sh | sh

मॉडल खींचो

निम्न आदेश के माध्यम से उपलब्ध एलएलएम मॉडल प्राप्त करें:

ollama pull llama3.1

यह मॉडल का डिफ़ॉल्ट टैग किया गया संस्करण डाउनलोड करेगा। आमतौर पर, डिफ़ॉल्ट नवीनतम, सबसे छोटे आकार-पैरामीटर मॉडल को इंगित करता है। इस मामले में, यह llama3.1:8b मॉडल होगा।

मॉडल का दूसरा संस्करण डाउनलोड करने के लिए, आप यहां जा सकते हैं: https://ollama.com/library/llama3.1 और इंस्टॉल करने के लिए संस्करण का चयन करें, और फिर मॉडल और उसके संस्करण संख्या के साथ ओलामा पुल कमांड चलाएं . उदाहरण: ओलामा पुल लामा3.1:70बी

मैक पर, मॉडल ~/.ollama/models

लिनक्स (या डब्लूएसएल) पर, मॉडल /usr/share/ollama/.ollama/models

मॉडल परोसें

डेस्कटॉप एप्लिकेशन को चलाए बिना ओलामा शुरू करने के लिए निम्न कमांड चलाएँ।

ollama serve

सभी मॉडल स्वचालित रूप से लोकलहोस्ट पर परोसे जाते हैं:11434

एक नया फ़ोल्डर बनाएं, इसे कोड संपादक के साथ खोलें

अपने कंप्यूटर पर एक नया फ़ोल्डर बनाएं और फिर इसे वीएस कोड जैसे कोड संपादक के साथ खोलें।

वर्चुअल वातावरण बनाएं और सक्रिय करें

टर्मिनल खोलें. वर्चुअल वातावरण .venv बनाने और इसे सक्रिय करने के लिए निम्नलिखित कमांड का उपयोग करें:

python3 -m venv .venv

source .venv/bin/activate

लैंगचैन लैंगचैन-ओलामा स्थापित करें

लैंगचेन और लैंगचैन-ओलामा स्थापित करने के लिए निम्नलिखित कमांड चलाएँ:

pip install -U langchain langchain-ollama

उपरोक्त कमांड पायथन में लैंगचेन और लैंगचेन-ओलामा पैकेज को स्थापित या अपग्रेड करेगा। -U ध्वज यह सुनिश्चित करता है कि इन पैकेजों के नवीनतम संस्करण स्थापित किए गए हैं, जो पहले से मौजूद किसी भी पुराने संस्करण को प्रतिस्थापित कर रहे हैं।

पायथन में ओपन सोर्स मॉडल के साथ कस्टम एजेंट बनाएं

उदाहरण के लिए एक पायथन फ़ाइल बनाएं: main.py और निम्नलिखित कोड जोड़ें:

from langchain_ollama import ChatOllama
from langchain.agents import tool
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.agents.format_scratchpad.openai_tools import (
    format_to_openai_tool_messages,
)
from langchain.agents import AgentExecutor
from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser


llm = ChatOllama(
            model="llama3.1",
            temperature=0,
            verbose=True
        )

@tool
def get_word_length(word: str) -> int:
    """Returns the length of a word."""
    return len(word)


tools = [get_word_length]



prompt = ChatPromptTemplate.from_messages(
            [
                (
                    "system",
                    "You are very powerful assistant",
                ),
                ("user", "{input}"),
                MessagesPlaceholder(variable_name="agent_scratchpad"),
            ]
        )

llm_with_tools = llm.bind_tools(tools)

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

# Create an agent executor by passing in the agent and tools
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
result = agent_executor.invoke({"input": "How many letters in the word educa"})

if result:
    print(f"[Output] --> {result['output']}")
else:
    print('There are no result..')

उपरोक्त कोड स्निपेट उपयोगकर्ता इनपुट को संसाधित करने और शब्द की लंबाई की गणना करने वाले एक कस्टम टूल का उपयोग करने के लिए ChatOllama मॉडल (llama3.1) का उपयोग करके एक लैंगचेन एजेंट सेट करता है। यह एजेंट के लिए एक प्रॉम्प्ट टेम्पलेट को परिभाषित करता है, टूल को भाषा मॉडल से बांधता है, और एक एजेंट का निर्माण करता है जो इनपुट को संसाधित करता है और मध्यवर्ती चरणों को प्रारूपित करता है। अंत में, यह एक विशिष्ट इनपुट के साथ एजेंट को आमंत्रित करने के लिए एक AgentExecutor बनाता है। हम "एडुका शब्द में कितने अक्षर हैं" पूछने के लिए एक सरल प्रश्न पास करते हैं और फिर हम आउटपुट प्रिंट करते हैं या इंगित करते हैं कि कोई परिणाम नहीं मिला।

जब हम दौड़ते हैं, तो हमें निम्नलिखित परिणाम मिलता है:

> Entering new AgentExecutor chain...

Invoking: `get_word_length` with `{'word': 'educa'}`


5The word "educa" has 5 letters.

> Finished chain.
[Output] --> The word "educa" has 5 letters.

आप देख सकते हैं कि एजेंट ने शब्द में अक्षरों की गिनती प्राप्त करने के लिए टूल को सही ढंग से कॉल करने के लिए मॉडल (llama3.1) का उपयोग किया।

निष्कर्ष

पढ़ने के लिए धन्यवाद।

ओलामा रेपो यहां देखें: https://github.com/ollama/ollama