DevOps இல் ஏஜென்டிக் AI இன் சாத்தியத்தை அன்லாக் செய்தல்: LangChain மற்றும் DSPy ஒருங்கிணைப்பின் தொழில்நுட்ப ஆய்வு

** DevOps இல் ஏஜென்டிக் AI இன் சாத்தியத்தைத் திறத்தல்: LangChain மற்றும் DSPy ஒருங்கிணைப்பின் தொழில்நுட்ப ஆய்வு**

அறிமுகம்

DevOps நிலப்பரப்பு வேகமாக உருவாகி வருகிறது, இது வேகமான, அதிக நம்பகமான மற்றும் பாதுகாப்பான மென்பொருள் விநியோகத்திற்கான அதிகரித்து வரும் தேவையால் இயக்கப்படுகிறது. இந்த மாற்றத்தின் முக்கிய இயக்கிகளில் ஒன்று செயற்கை நுண்ணறிவு (AI) மற்றும் இயந்திர கற்றல் (ML) ஆகியவற்றை DevOps பணிப்பாய்வுகளில் ஒருங்கிணைப்பதாகும். இந்தக் கட்டுரையில், DevOps இல் உள்ள Agentic AI இன் கருத்தை ஆராய்வோம், LangChain மற்றும் DSPy ஆகியவற்றின் ஒருங்கிணைப்பை மையமாகக் கொண்டு, அளவிடக்கூடிய மற்றும் பாதுகாப்பான மென்பொருள் கட்டமைப்பை செயல்படுத்தும் இரண்டு சக்திவாய்ந்த ஆர்கெஸ்ட்ரேஷன் கருவிகள்.

DevOps இல் ஏஜென்டிக் AI என்றால் என்ன?

DevOps இல் உள்ள ஏஜென்டிக் AI என்பது DevOps பணிப்பாய்வுகளை தானியங்குபடுத்துவதற்கும் மேம்படுத்துவதற்கும் AI முகவர்களின் பயன்பாட்டைக் குறிக்கிறது. இந்த முகவர்கள் கண்காணிப்பு, பதிவு செய்தல் மற்றும் வரிசைப்படுத்துதல், அதிக மூலோபாய மற்றும் ஆக்கப்பூர்வமான பணிகளுக்கு மனித வளங்களை விடுவித்தல் போன்ற பணிகளைச் செய்ய முடியும். DevOps இல் Agentic AI இன் முக்கிய கொள்கைகள் சூழல் பொறியியல் மற்றும் ZeroOps ஆகும்.

சூழல் பொறியியல்

சூழல் பொறியியல் என்பது DevOps பணிப்பாய்வுகள் செயல்படும் சூழலைப் பற்றிய பகிரப்பட்ட புரிதலை உருவாக்கும் செயல்முறையாகும். DevOps பணிப்பாய்வுகளில் AI முகவர்களின் நடத்தையை நிர்வகிக்கும் விதிகள், கட்டுப்பாடுகள் மற்றும் இலக்குகளை வரையறுப்பது இதில் அடங்கும். சூழல் பொறியியல், AI முகவர்கள் தகவலறிந்த முடிவுகளை எடுக்கவும், நிறுவனத்தின் குறிக்கோள்கள் மற்றும் நோக்கங்களுடன் இணைந்த செயல்களை மேற்கொள்ளவும் உதவுகிறது.

ஜீரோஆப்ஸ்

ZeroOps என்பது DevOps கொள்கையாகும், இது DevOps பணிப்பாய்வுகளில் மனித தலையீட்டின் தேவையை அகற்றுவதை நோக்கமாகக் கொண்டுள்ளது. மனித தலையீடு இல்லாமல் சூழலில் ஏற்படும் மாற்றங்களைக் கண்டறிந்து பதிலளிக்கக்கூடிய சுய-குணப்படுத்துதல், சுய-உகப்பாக்கம் மற்றும் சுய-பாதுகாப்பு அமைப்பை உருவாக்குவதன் மூலம் இது அடையப்படுகிறது. கணினியில் ஏற்படும் மாற்றங்களைக் கண்காணிக்கவும், பகுப்பாய்வு செய்யவும் மற்றும் பதிலளிக்கவும் கூடிய AI முகவர்களைப் பயன்படுத்துவதன் மூலம் ZeroOps சாத்தியமாகிறது.

LangChain மற்றும் DSPy ஒருங்கிணைப்பு

LangChain மற்றும் DSPy ஆகியவை DevOps இல் Agentic AI இன் ஒருங்கிணைப்பை செயல்படுத்தும் இரண்டு சக்திவாய்ந்த ஆர்கெஸ்ட்ரேஷன் கருவிகள் ஆகும். LangChain என்பது பைதான் நூலகமாகும், இது உரையாடல் AI முகவர்களை உருவாக்குவதற்கான கட்டமைப்பை வழங்குகிறது, DSPy என்பது ரஸ்ட் அடிப்படையிலான நூலகமாகும், இது விநியோகிக்கப்பட்ட அமைப்புகளை உருவாக்குவதற்கான கட்டமைப்பை வழங்குகிறது.

LangChain மற்றும் DSPy ஆகியவற்றை ஒருங்கிணைப்பதன் மூலம், டெவலப்பர்கள், Agentic AI இன் சக்தியைப் பயன்படுத்தக்கூடிய அளவிடக்கூடிய மற்றும் பாதுகாப்பான மென்பொருள் கட்டமைப்பை உருவாக்க முடியும். இந்த ஒருங்கிணைப்பை எவ்வாறு அடையலாம் என்பதற்கான எடுத்துக்காட்டு இங்கே:

லாங்செயின் இறக்குமதி
langchain.chat_models இலிருந்து ChatOpenAIஐ இறக்குமதி செய்க
langchain.llms இலிருந்து LLMOpenAI ஐ இறக்குமதி செய்க

# அரட்டை மாதிரி மற்றும் LLM ஐ வரையறுக்கவும்
chat_model = ChatOpenAI()
llm = LLMOpenAI()

# LangChain முகவரை வரையறுக்கவும்
முகவர் = langchain.Agent(
    செயின்=லாங்செயின்.செயின்(
        llm=llm,
        chat_model=chat_model
    )
)

# DSPy முகவரை வரையறுக்கவும்
dsp_agent = dspy.Agent(
    name="my_agent",
    விளக்கம்="எனது DSPy முகவர்"
)

# LangChain மற்றும் DSPy முகவர்களை ஒருங்கிணைக்கவும்
langchain_agent = langchain.Agent(
    செயின்=லாங்செயின்.செயின்(
        llm=llm,
        chat_model=chat_model,
        dsp_agent=dsp_agent
    )
)

# ஒரு பணியைச் செய்ய ஒருங்கிணைந்த முகவரைப் பயன்படுத்தவும்
langchain_agent.execute("பயன்பாட்டை உற்பத்திக்கு வரிசைப்படுத்து")

முதல் 5-10 அதிகம் பயன்படுத்தப்பட்ட கட்டளைகள்/துணுக்குகள்

LangChain மற்றும் DSPyக்கு அதிகம் பயன்படுத்தப்படும் 5-10 கட்டளைகள்/துணுக்குகள் இங்கே:

1. LangChain முகவர் உருவாக்கம்: langchain.Agent(chain=langchain.Chain(llm=llm, chat_model=chat_model))
2. DSPy முகவர் உருவாக்கம்: dspy.Agent(name="my_agent", description="My DSPy agent")
3. LangChain முகவர் செயல்படுத்தல்: langchain_agent.execute("பயன்பாட்டை உற்பத்திக்கு வரிசைப்படுத்து")
4. DSPy முகவர் செயல்படுத்தல்: dsp_agent.execute("பயன்பாட்டை உற்பத்திக்கு வரிசைப்படுத்து")
5. LangChain சங்கிலி வரையறை: langchain.Chain(llm=llm, chat_model=chat_model)
6. DSPy சங்கிலி வரையறை: dspy.Chain(name="my_chain", description="My DSPy chain")
7. LangChain முகவர் பதிவு: langchain_agent.register()
8. DSPy முகவர் பதிவு: dsp_agent.register()
9. LangChain முகவர் பதிவு நீக்கம்: langchain_agent.unregister()
10. DSPy முகவர் பதிவு நீக்கம்: dsp_agent.unregister()

காட்சிப்படுத்தல்

Chart.js ஐப் பயன்படுத்தி LangChain மற்றும் DSPy ஒருங்கிணைப்பின் காட்சிப்படுத்தல் இங்கே:

{
  "வகை": "பார்",
  "தரவு": {
    "லேபிள்கள்": ["LangChain", "DSPy"],
    "தரவுத்தொகுப்புகள்": [
      {
        "லேபிள்": "முகவர் உருவாக்கம்",
        "தரவு": [10, 5],
        "பின்னணி நிறம்": ["#4CAF50", "#FF9800"]
      },
      {
        "லேபிள்": "முகவர் செயல்படுத்தல்",
        "தரவு": [8, 6],
        "பின்னணி நிறம்": ["#2196F3", "#9C27B0"]
      },
      {
        "லேபிள்": "செயின் டெபினிஷன்",
        "தரவு": [12, 4],
        "பின்னணி நிறம்": ["#8BC34A", "#3F51B5"]
      }
    ]
  },
  "விருப்பங்கள்": {
    "தலைப்பு": {
      "காட்சி": உண்மை,
      "உரை": "LangChain மற்றும் DSPy ஒருங்கிணைப்பு"
    },
    "புராணக்கதை": {
      "காட்சி": உண்மை
    }
  }
}

முடிவு

LangChain மற்றும் DSPy இன் ஒருங்கிணைப்பு, DevOps இல் Agentic AI இன் ஆற்றலைப் பயன்படுத்தும் அளவிடக்கூடிய மற்றும் பாதுகாப்பான மென்பொருள் கட்டமைப்பை உருவாக்க உதவுகிறது. சூழல் பொறியியல் மற்றும் ZeroOps கொள்கைகளைப் பயன்படுத்துவதன் மூலம், டெவலப்பர்கள் சுய-குணப்படுத்துதல், சுய-உகப்பாக்கம் மற்றும் சுய-பாதுகாப்பு அமைப்புகளை உருவாக்க முடியும், அவை மனித தலையீடு இல்லாமல் சூழலில் ஏற்படும் மாற்றங்களைக் கண்டறிந்து பதிலளிக்க முடியும். LangChain மற்றும் DSPy ஆகியவற்றிற்கான சிறந்த 5-10 கட்டளைகள்/துணுக்குகள் Chart.js ஐப் பயன்படுத்தி ஒருங்கிணைப்பின் காட்சிப்படுத்தலுடன் வழங்கப்பட்டுள்ளன.