லாங்செயின் மற்றும் DSPy உடன் AI- இயங்கும் டெவொப்களை ஒழுங்கமைத்தல்: முகவர் அடிப்படையிலான ஆட்டோமேஷனுக்கான தொழில்நுட்ப வழிகாட்டி

அறிமுகம்

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

LangChain என்றால் என்ன?

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

DSPy என்றால் என்ன?

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

DevOps பைப்லைன்களுடன் LangChain மற்றும் DSPy ஆகியவற்றை ஒருங்கிணைத்தல்

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

AI முகவரை வரையறுக்கவும்: குறியீட்டைப் பயன்படுத்துதல், இயங்கும் சோதனைகள் மற்றும் செயல்திறனைக் கண்காணிப்பது போன்ற பணிகளைச் செய்யக்கூடிய LangChain முகவரை உருவாக்கவும்.
DevOps கருவிகளுடன் ஒருங்கிணைக்கவும்: ஜென்கின்ஸ், GitLab CI/CD அல்லது Docker போன்ற DevOps கருவிகளுடன் AI முகவரை ஒருங்கிணைக்கவும்.
AI முகவரை உள்ளமைக்கவும்: தரவுத்தளங்கள், APIகள் அல்லது கோப்பு முறைமைகள் போன்ற பல்வேறு தரவு மூலங்களுடன் தொடர்பு கொள்ள AI முகவரை உள்ளமைக்கவும்
**AI முகவரைப் பயிற்றுவி

நடைமுறை எடுத்துக்காட்டு: LangChain மற்றும் DSPy உடன் குறியீட்டைப் பயன்படுத்துதல்

LangChain மற்றும் DSPy ஐப் பயன்படுத்தி குறியீட்டை எவ்வாறு வரிசைப்படுத்துவது என்பதற்கான எளிய எடுத்துக்காட்டு இங்கே:

லாங்செயின் இறக்குமதி
langchain. முகவர் இறக்குமதி முகவரிடமிருந்து
langchain.llms இலிருந்து LLM ஐ இறக்குமதி செய்கிறது

# LangChain முகவரை உருவாக்கவும்
முகவர் = முகவர்(
    llm=LLM(
        model_name="davinci",
        max_tokens=2048,
        வெப்பநிலை=0.5,
    ),
    சங்கிலி =[
        langchain.Chain(
            name="deploy_code",
            படிகள்=[
                langchain.Step(
                    பெயர்="git_clone",
                    func=lambda: git_clone("https://github.com/user/repo.git"),
                ),
                langchain.Step(
                    name="build_code",
                    func=lambda: build_code(),
                ),
                langchain.Step(
                    name="deploy_code",
                    func=lambda: deploy_code(),
                ),
            ],
        ),
    ],
)

# AI முகவரைப் பயன்படுத்தி குறியீட்டைப் பயன்படுத்தவும்
agent.deploy_code()

இந்த எடுத்துக்காட்டில், மூன்று படிகளைச் செய்யும் LangChain முகவரை உருவாக்குகிறோம்:

Git ஐப் பயன்படுத்தி குறியீடு களஞ்சியத்தை குளோன் செய்கிறது.
உருவாக்கக் கருவியைப் பயன்படுத்தி குறியீட்டை உருவாக்குகிறது.
வரிசைப்படுத்தல் கருவியைப் பயன்படுத்தி குறியீட்டைப் பயன்படுத்துகிறது.

AI முகவர், முடிவுகளை எடுக்கவும் பணிகளைச் செய்யவும் ஒரு மொழி மாதிரியை (LLM) பயன்படுத்துகிறார்.

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

LangChain மற்றும் DSPy க்கான பொதுவாகப் பயன்படுத்தப்படும் சில கட்டளைகள் மற்றும் துணுக்குகள் இங்கே:

ஒரு LangChain முகவரை உருவாக்கவும்: agent = Agent(llm=LLM(model_name="davinci", max_tokens=2048, வெப்பநிலை=0.5), chain=[langchain.Chain(name="deploy_code", Steps=[langchain.="Fune=da_git: git_clone("https://github.com/user/repo.git"))])])
AI முகவரைப் பயன்படுத்தி குறியீட்டைப் பயன்படுத்தவும்: agent.deploy_code()
**AI முகவரைப் பயிற்றுவி
DevOps கருவிகளுடன் ஒருங்கிணைக்கவும்: agent.integrate_with_jenkins()
AI முகவரை உள்ளமைக்கவும்: agent.configure(llm=LLM(model_name="davinci", max_tokens=2048, வெப்பநிலை=0.5))
AI ஏஜென்ட்டின் நிலையைப் பெறவும்: agent.status()
AI ஏஜென்ட்டின் பதிவுகளைப் பெறவும்: agent.logs()
AI ஏஜென்ட்டின் உள்ளமைவைப் புதுப்பிக்கவும்: agent.update_config(llm=LLM(model_name="davinci", max_tokens=2048, வெப்பநிலை=0.5))
AI முகவரை நீக்கு: agent.delete()
AI ஏஜென்ட்டின் அளவீடுகளைப் பெறவும்: agent.metrics()

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

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

{
  "வகை": "பார்",
  "தரவு": {
    "லேபிள்கள்": ["LangChain", "DSPy"],
    "தரவுத்தொகுப்புகள்": [
      {
        "லேபிள்": "கூறுகள்",
        "தரவு": [10, 5],
        "பின்னணி நிறம்": ["#4CAF50", "#FF9800"],
        "borderColor": ["#3e8e41", "#ff9900"],
        "எல்லை அகலம்": 1
      }
    ]
  },
  "விருப்பங்கள்": {
    "தலைப்பு": {
      "காட்சி": உண்மை,
      "உரை": "LangChain மற்றும் DSPy கட்டிடக்கலை"
    },
    "புராணக்கதை": {
      "காட்சி": உண்மை
    },
    "செதில்கள்": {
      "yAxes": [
        {
          "உண்ணி": {
            "beginAtZero": உண்மை
          }
        }
      ]
    }
  }
}

இந்த காட்சிப்படுத்தல் LangChain மற்றும் DSPy இல் உள்ள கூறுகளின் எண்ணிக்கையைக் காட்டுகிறது.

முடிவு

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