Kiro නියෝජිතයෙකු සාදන්න

Kiro සහ LangChain සමඟ DevOps ස්වයංක්‍රීයකරණය සඳහා නියෝජිත AI උත්තේජනය කිරීම

හැඳින්වීම

වර්තමාන වේගවත් මෘදුකාංග සංවර්ධන භූ දර්ශනය තුළ, DevOps කණ්ඩායම් ඔවුන්ගේ අඛණ්ඩ ඒකාබද්ධතාවය සහ අඛණ්ඩ යෙදවීමේ (CI/CD) නල මාර්ගවල කාර්යක්ෂමතාව සහ විශ්වසනීයත්වය වැඩි දියුණු කිරීමට ක්‍රම නිරන්තරයෙන් සොයමින් සිටිති. DevOps කාර්යයන් ස්වයංක්‍රීය කිරීමට සහ ප්‍රශස්ත කිරීමට හැකි බුද්ධිමත් නියෝජිතයන් නිර්මාණය කිරීමට හැකියාව ලබා දෙන නියෝජිත AI භාවිතා කිරීම එක් පොරොන්දු ප්‍රවේශයකි. මෙම ලිපියෙන්, අපි DevOps ස්වයංක්‍රීයකරණ ක්ෂේත්‍රයේ විප්ලවීය වෙනසක් ඇති කරන අති නවීන රාමු දෙකක් වන Kiro සහ LangChain භාවිතයෙන් AI-බලවත් නියෝජිතයන් ක්‍රියාත්මක කරන්නේ කෙසේදැයි සොයා බලමු.

Agentic AI යනු කුමක්ද?

Agentic AI යනු මානව නියෝජිතයෙකු මෙන් ස්වයංක්‍රීයව කාර්යයන් ඉටු කිරීමට නිර්මාණය කර ඇති කෘතිම බුද්ධි වර්ගයකි. DevOps හි සන්දර්භය තුළ, මෘදුකාංග යෙදුම් තැනීම, පරීක්ෂා කිරීම සහ යෙදවීම වැනි කාර්යයන් ස්වයංක්‍රීය කිරීමට නියෝජිත AI භාවිතා කළ හැක. යන්ත්‍ර ඉගෙනීම සහ ස්වාභාවික භාෂා සැකසුම් (NLP) ශිල්පීය ක්‍රම උපයෝගී කර ගැනීමෙන්, නියෝජිත AI නියෝජිතයින්ට අත්දැකීම් වලින් ඉගෙන ගත හැකි අතර වෙනස්වන පරිසරයන්ට අනුවර්තනය විය හැකි අතර, ඒවා සංකීර්ණ සහ ගතික DevOps කාර්ය ප්‍රවාහයන් සඳහා වඩාත් සුදුසු වේ.

Kiro සහ LangChain හඳුන්වා දීම

Kiro සහ LangChain යනු නියෝජිත AI පද්ධති ගොඩනැගීම සඳහා විශේෂයෙන් නිර්මාණය කර ඇති විවෘත මූලාශ්‍ර රාමු දෙකකි. Kiro යනු බුද්ධිමය නියෝජිතයන් ගොඩනැගීම සඳහා ශක්තිමත් සහ පරිමාණය කළ හැකි වේදිකාවක් සපයන මලකඩ මත පදනම් වූ රාමුවක් වන අතර LangChain යනු NLP සහ භාෂා අවබෝධය කෙරෙහි අවධානය යොමු කරන Python මත පදනම් වූ රාමුවකි.

කිරෝ: බුද්ධිමත් නියෝජිතයන් ගොඩනැගීම සඳහා මලකඩ පදනම් වූ රාමුවක්

Kiro යනු බුද්ධිමත් නියෝජිතයන් ගොඩනැගීම සඳහා පුළුල් වේදිකාවක් සපයන නවීන මලකඩ පදනම් වූ රාමුවකි. Kiro සමඟින්, සංවර්ධකයින්ට විවිධ පද්ධති, සේවා, සහ දත්ත මූලාශ්‍ර සමඟ අන්තර් ක්‍රියා කළ හැකි නියෝජිතයන් නිර්මාණය කළ හැකි අතර, එවැනි කාර්යයන් ඉටු කළ හැක:

• වැඩ ප්‍රවාහ සහ ක්‍රියාවලි ස්වයංක්‍රීය කිරීම
• දත්ත විශ්ලේෂණය සහ තීරණ ගැනීම
• මිනිසුන් සහ අනෙකුත් පද්ධති සමඟ සන්නිවේදනය කිරීම

Kiro හි ගෘහනිර්මාණ ශිල්පය නිර්මාණය කර ඇත්තේ ඉහළ පරිමාණය කළ හැකි සහ නම්‍යශීලී වන අතර, එය මහා පරිමාණ DevOps ස්වයංක්‍රීයකරණ ව්‍යාපෘති සඳහා කදිම තේරීමක් කරයි.

LangChain: NLP සහ භාෂා අවබෝධය සඳහා පයිතන් මත පදනම් වූ රාමුවක්

LangChain යනු NLP සහ භාෂා අවබෝධය කෙරෙහි අවධානය යොමු කරන පයිතන් මත පදනම් වූ රාමුවකි. LangChain සමඟින්, සංවර්ධකයින්ට මිනිසුන්ට සමාන භාෂාවක් තේරුම් ගත හැකි සහ උත්පාදනය කළ හැකි නියෝජිතයන් නිර්මාණය කළ හැකි අතර, එවැනි කාර්යයන් ඉටු කළ හැකිය:

ස්වභාවික භාෂා සැකසුම් (NLP)

• පෙළ විශ්ලේෂණය සහ හැඟීම් විශ්ලේෂණය
• භාෂා පරිවර්තනය සහ උත්පාදනය

LangChain හි ගෘහ නිර්මාණ ශිල්පය ඉතා මොඩියුලර් සහ විස්තීරණ ලෙස නිර්මාණය කර ඇති අතර එය අභිරුචි NLP සහ භාෂා අවබෝධය හැකියාවන් ගොඩනැගීම සඳහා කදිම තේරීමක් කරයි.

Kiro සහ LangChain සමඟ AI-බලවත් නියෝජිතයන් ක්‍රියාත්මක කිරීම

Kiro සහ LangChain වල බලය ප්‍රදර්ශනය කිරීම සඳහා, CI/CD නල මාර්ගයක් ස්වයංක්‍රීය කරන AI බලයෙන් ක්‍රියාත්මක වන නියෝජිතයෙකු තැනීමේ සරල උදාහරණයක් සලකා බලමු. මෙම උදාහරණයේදී, අපි Git ගබඩාවක් සමඟ අන්තර්ක්‍රියා කළ හැකි නියෝජිතයෙකු නිර්මාණය කිරීමට, කේතය ගොඩනඟා පරීක්ෂා කිරීමට සහ යෙදුම ක්ලවුඩ් වේදිකාවකට යෙදවීමට Kiro භාවිතා කරන්නෙමු.

CI/CD නල මාර්ගයක් ස්වයංක්‍රීය කරන Kiro නියෝජිතයෙකු නිර්මාණය කරන්නේ කෙසේද යන්න පෙන්නුම් කරන සරල කේත බ්ලොක් එකක් මෙන්න:

කිරෝ ආනයනය කරන්න
Langchain ආනයනය LLAMA වෙතින්


නියෝජිතයා = kiro.Agent(
    නම="ci_cd_agent",
    විස්තරය="ස්වයංක්‍රීය CI/CD නල මාර්ගය",
    ක්රියා =[
        kiro.Action(
            name="git_clone",
            description="Git ගබඩාව ක්ලෝන කරයි",
            කේතය="""
                git ආනයනය කරන්න
                repo = git.Repo.clone("https://github.com/user/repo.git")
            """
        ),
        kiro.Action(
            නම="ගොඩනැගීමට",
            description="කේතය ගොඩනඟයි",
            කේතය="""
                ආනයන උපක්‍රියාවලිය
                subprocess.run(["make", "build"])
            """
        ),
        kiro.Action(
            නම = "පරීක්ෂණය",
            description="පරීක්ෂණ ධාවනය කරයි",
            කේතය="""
                ආනයන උපක්‍රියාවලිය
                subprocess.run(["make", "test"])
            """
        ),
        kiro.Action(
            නම=" යෙදවීම",
            description="යෙදුම යොදවයි",
            කේතය="""
                ආනයන උපක්‍රියාවලිය
                subprocess.run(["make", "deploy"])
            """
        )
    ]
)

# LangChain LLAMA ආකෘතියක් සාදන්න
ලාමා = ලාමා(
    name="llama_model",
    විස්තරය="භාෂා අවබෝධය සඳහා LLAMA ආකෘතිය",
    කේතය="""
        langchain ආනයනය කරන්න
        ආකෘතිය = langchain.LLAMA(
            name="llama_model",
            විස්තරය="භාෂා අවබෝධය සඳහා LLAMA ආකෘතිය",
            කේතය="""
                langchain ආනයනය කරන්න
                ආකෘතිය = langchain.LLAMA(
                    name="llama_model",
                    විස්තරය="භාෂා අවබෝධය සඳහා LLAMA ආකෘතිය",
                    කේතය="""
                        def process_text(text):
                            # LLAMA ආකෘතිය භාවිතයෙන් පෙළ සකසන්න
                            ආපසු පෙළ
                    """
                )
            """
        )
    """
)

# LangChain LLAMA ආකෘතිය භාවිතා කරන Kiro නියෝජිතයෙකු සාදන්න
නියෝජිතයා = kiro.Agent(
    නම="ci_cd_agent",
    විස්තරය="ස්වයංක්‍රීය CI/CD නල මාර්ගය",
    ක්රියා =[
        kiro.Action(
            name="git_clone",
            description="Git ගබඩාව ක්ලෝන කරයි",
            කේතය="""
                git ආනයනය කරන්න
                repo = git.Repo.clone("https://github.com/user/repo.git")
            """
        ),
        kiro.Action(
            නම="ගොඩනැගීමට",
            description="කේතය ගොඩනඟයි",
            කේතය="""
                ආනයන උපක්‍රියාවලිය
                subprocess.run(["make", "build"])
            """
        ),
        kiro.Action(
            නම = "පරීක්ෂණය",
            description="පරීක්ෂණ ධාවනය කරයි",
            කේතය="""
                ආනයන උපක්‍රියාවලිය
                subprocess.run(["make", "test"])
            """
        ),
        kiro.Action(
            නම=" යෙදවීම",
            description="යෙදුම යොදවයි",
            කේතය="""
                ආනයන උපක්‍රියාවලිය
                subprocess.run(["make", "deploy"])
            """
        )
    ],
    language_model=ලාමා
)

# නියෝජිතයා ධාවනය කරන්න
agent.run()

භාෂා අවබෝධය සඳහා LangChain LLAMA මාදිලිය භාවිතයෙන් CI/CD නල මාර්ගයක් ස්වයංක්‍රීය කරන Kiro නියෝජිතයෙකු නිර්මාණය කරන්නේ කෙසේද යන්න මෙම කේත අවහිර කිරීම පෙන්නුම් කරයි. නියෝජිතයාට Git ගබඩාවක් සමඟ අන්තර් ක්‍රියා කිරීමට, කේතය ගොඩනඟා පරීක්ෂා කිරීමට සහ යෙදුම වලාකුළු වේදිකාවකට යෙදවිය හැකිය.

ඉහළම 5-10 වැඩිපුරම භාවිතා කරන ලද විධාන/Snippets

මෙන්න Kiro සහ LangChain සඳහා වැඩිපුරම භාවිතා කරන ලද විධාන/snippets 5-10:

1. kiroutil init: නව Kiro ව්‍යාපෘතියක් ආරම්භ කරයි.
2. kiroutil build: Kiro නියෝජිතයකු ගොඩනඟයි.
3. langchain init: නව LangChain ව්‍යාපෘතියක් ආරම්භ කරයි.
4. langchain build: LangChain ආකෘතියක් ගොඩනඟයි.
5. kirotil run: Kiro නියෝජිතයෙකු ධාවනය කරයි.
6. langchain test: LangChain ආකෘතියක් පරීක්ෂා කරයි.
7. kiroutil deploy: Cloud Platform එකකට Kiro නියෝජිතයෙකු යොදවයි.
8. langchain evaluate: LangChain ආකෘතියක් ඇගයීම.
9. kiroutil debug: Kiro නියෝජිතයෙකු නිදොස් කරයි.
10. langchain visualize: LangChain ආකෘතියක් දෘශ්‍යමාන කරයි.

දෘෂ්‍යකරණය

මෙන්න Chart.js භාවිතයෙන් Kiro සහ LangChain ගෘහ නිර්මාණ ශිල්පයේ දෘශ්‍යකරණයකි: ''''ජේසන් { "වර්ගය": "බාර්", "දත්ත": { "ලේබල්": ["කිරෝ", "LangChain"], "දත්ත කට්ටල": [ { "ලේබලය": "ගෘහ නිර්මාණ ශිල්පය", "දත්ත": [100, 80], "backgroundColor": ["#4CAF50", "#FF9800"] } ] }, "විකල්ප": { "මාතෘකාව": { "දර්ශණය": ඇත්ත, "text": "Kiro සහ LangChain ගෘහ නිර්මාණ ශිල්පය" }, "පුරාවෘත්තය": { "දර්ශණය": ඇත්ත } } }

මෙම දෘශ්‍යකරණය Kiro සහ LangChain හි ඉහළ මට්ටමේ ගෘහ නිර්මාණ ශිල්පය පෙන්නුම් කරයි, ඒවායේ ශක්තීන් සහ දුර්වලතා ඉස්මතු කරයි.

** නිගමනය **

මෙම ලිපියෙන්, අපි Kiro සහ LangChain භාවිතා කරමින් DevOps ස්වයංක්‍රීයකරණය සඳහා නියෝජිත AI හි බලය ගවේෂණය කර ඇත. මෙම අති නවීන රාමු භාවිතා කිරීමෙන්, සංවර්ධකයින්ට CI/CD නල මාර්ග ස්වයංක්‍රීය කිරීමට සහ ප්‍රශස්ත කිරීමට, මෘදුකාංග බෙදා හැරීමේ කාර්යක්ෂමතාව වැඩි දියුණු කිරීමට සහ දෝෂ ඇතිවීමේ අවදානම අඩු කිරීමට හැකි බුද්ධිමත් නියෝජිතයන් නිර්මාණය කළ හැකිය. Kiro සහ LangChain සමඟින්, සංවර්ධකයින්ට අභිරුචි NLP සහ භාෂා අවබෝධ කිරීමේ හැකියාවන් නිර්මාණය කළ හැකි අතර විවිධ පද්ධති, සේවා සහ දත්ත මූලාශ්‍ර සමඟ අන්තර් ක්‍රියා කළ හැකිය. භාෂා අවබෝධය සඳහා LangChain LLAMA ආකෘතිය භාවිතයෙන් CI/CD නල මාර්ගයක් ස්වයංක්‍රීය කරන Kiro නියෝජිතයෙකු නිර්මාණය කරන්නේ කෙසේද යන්න පෙන්නුම් කරන සරල කේත බ්ලොක් එකක් ද අපි සපයා ඇත.