ಕಿರೋ ಮತ್ತು ಲ್ಯಾಂಗ್‌ಚೈನ್‌ನೊಂದಿಗೆ ಡೆವೊಪ್ಸ್ ಆಟೊಮೇಷನ್‌ಗಾಗಿ ಏಜೆಂಟಿಕ್ ಎಐ ಅನ್ನು ನಿಯಂತ್ರಿಸುವುದು

ಪರಿಚಯ

ಇಂದಿನ ವೇಗದ ಗತಿಯ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ಭೂದೃಶ್ಯದಲ್ಲಿ, DevOps ತಂಡಗಳು ತಮ್ಮ ನಿರಂತರ ಏಕೀಕರಣ ಮತ್ತು ನಿರಂತರ ನಿಯೋಜನೆ (CI/CD) ಪೈಪ್‌ಲೈನ್‌ಗಳ ದಕ್ಷತೆ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಸುಧಾರಿಸಲು ನಿರಂತರವಾಗಿ ಮಾರ್ಗಗಳನ್ನು ಹುಡುಕುತ್ತಿವೆ. ಒಂದು ಭರವಸೆಯ ವಿಧಾನವೆಂದರೆ ಏಜೆಂಟಿಕ್ AI ಅನ್ನು ನಿಯಂತ್ರಿಸುವುದು, ಇದು DevOps ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮತ್ತು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಬಲ್ಲ ಬುದ್ಧಿವಂತ ಏಜೆಂಟ್‌ಗಳ ರಚನೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಈ ಲೇಖನದಲ್ಲಿ, DevOps ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಕ್ಷೇತ್ರದಲ್ಲಿ ಕ್ರಾಂತಿಯನ್ನುಂಟುಮಾಡುವ ಎರಡು ಅತ್ಯಾಧುನಿಕ ಚೌಕಟ್ಟುಗಳಾದ Kiro ಮತ್ತು LangChain ಅನ್ನು ಬಳಸಿಕೊಂಡು AI-ಚಾಲಿತ ಏಜೆಂಟ್‌ಗಳನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಎಂಬುದನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ.

ಏಜೆಂಟಿಕ್ AI ಎಂದರೇನು?

ಏಜೆಂಟಿಕ್ AI ಎನ್ನುವುದು ಒಂದು ರೀತಿಯ ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಇದು ಮಾನವ ಏಜೆಂಟ್‌ನಂತೆ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಾಯತ್ತವಾಗಿ ನಿರ್ವಹಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. DevOps ಸಂದರ್ಭದಲ್ಲಿ, ಸಾಫ್ಟ್‌ವೇರ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವುದು, ಪರೀಕ್ಷಿಸುವುದು ಮತ್ತು ನಿಯೋಜಿಸುವಂತಹ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಏಜೆಂಟ್ AI ಅನ್ನು ಬಳಸಬಹುದು. ಯಂತ್ರ ಕಲಿಕೆ ಮತ್ತು ನೈಸರ್ಗಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆ (NLP) ತಂತ್ರಗಳನ್ನು ನಿಯಂತ್ರಿಸುವ ಮೂಲಕ, ಏಜೆಂಟ್ AI ಏಜೆಂಟ್‌ಗಳು ಅನುಭವದಿಂದ ಕಲಿಯಬಹುದು ಮತ್ತು ಬದಲಾಗುತ್ತಿರುವ ಪರಿಸರಕ್ಕೆ ಹೊಂದಿಕೊಳ್ಳಬಹುದು, ಅವುಗಳನ್ನು ಸಂಕೀರ್ಣ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ DevOps ಕೆಲಸದ ಹರಿವುಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ.

ಕಿರೋ ಮತ್ತು ಲ್ಯಾಂಗ್‌ಚೈನ್ ಅನ್ನು ಪರಿಚಯಿಸಲಾಗುತ್ತಿದೆ

Kiro ಮತ್ತು LangChain ಎರಡು ತೆರೆದ ಮೂಲ ಚೌಕಟ್ಟುಗಳಾಗಿದ್ದು, ಇವುಗಳನ್ನು ನಿರ್ದಿಷ್ಟವಾಗಿ ಏಜೆಂಟ್ AI ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಕಿರೊ ಎಂಬುದು ರಸ್ಟ್-ಆಧಾರಿತ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿದ್ದು ಅದು ಬುದ್ಧಿವಂತ ಏಜೆಂಟ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ದೃಢವಾದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ, ಆದರೆ ಲ್ಯಾಂಗ್‌ಚೈನ್ ಪೈಥಾನ್-ಆಧಾರಿತ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿದ್ದು ಅದು NLP ಮತ್ತು ಭಾಷಾ ತಿಳುವಳಿಕೆಯನ್ನು ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ.

ಕಿರೋ: ಬುಲ್ಡಿಂಗ್ ಇಂಟೆಲಿಜೆಂಟ್ ಏಜೆಂಟರಿಗಾಗಿ ತುಕ್ಕು ಆಧಾರಿತ ಚೌಕಟ್ಟು

ಕಿರೋ ಆಧುನಿಕ ರಸ್ಟ್-ಆಧಾರಿತ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿದ್ದು ಅದು ಬುದ್ಧಿವಂತ ಏಜೆಂಟ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಸಮಗ್ರ ವೇದಿಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. Kiro ನೊಂದಿಗೆ, ಡೆವಲಪರ್‌ಗಳು ವಿವಿಧ ಸಿಸ್ಟಮ್‌ಗಳು, ಸೇವೆಗಳು ಮತ್ತು ಡೇಟಾ ಮೂಲಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವ ಏಜೆಂಟ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ಅಂತಹ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಬಹುದು:

• ಕೆಲಸದ ಹರಿವುಗಳು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು
• ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು ಮತ್ತು ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದು
• ಮಾನವರು ಮತ್ತು ಇತರ ವ್ಯವಸ್ಥೆಗಳೊಂದಿಗೆ ಸಂವಹನ

Kiro ನ ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ಹೆಚ್ಚು ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವಂತೆ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ಇದು ದೊಡ್ಡ ಪ್ರಮಾಣದ DevOps ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಯೋಜನೆಗಳಿಗೆ ಸೂಕ್ತವಾದ ಆಯ್ಕೆಯಾಗಿದೆ.

LangChain: NLP ಮತ್ತು ಭಾಷಾ ತಿಳುವಳಿಕೆಗಾಗಿ ಪೈಥಾನ್ ಆಧಾರಿತ ಚೌಕಟ್ಟು

LangChain NLP ಮತ್ತು ಭಾಷಾ ತಿಳುವಳಿಕೆಯನ್ನು ಕೇಂದ್ರೀಕರಿಸುವ ಪೈಥಾನ್ ಆಧಾರಿತ ಚೌಕಟ್ಟಾಗಿದೆ. ಲ್ಯಾಂಗ್‌ಚೈನ್‌ನೊಂದಿಗೆ, ಡೆವಲಪರ್‌ಗಳು ಮಾನವ-ರೀತಿಯ ಭಾಷೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮತ್ತು ಉತ್ಪಾದಿಸುವ ಏಜೆಂಟ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ಅಂತಹ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಬಹುದು:

• ನೈಸರ್ಗಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆ (NLP)
• ಪಠ್ಯ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ಭಾವನೆ ವಿಶ್ಲೇಷಣೆ
• ಭಾಷಾ ಅನುವಾದ ಮತ್ತು ಪೀಳಿಗೆ

LangChain ನ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಹೆಚ್ಚು ಮಾಡ್ಯುಲರ್ ಮತ್ತು ವಿಸ್ತರಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ಇದು ಕಸ್ಟಮ್ NLP ಮತ್ತು ಭಾಷಾ ತಿಳುವಳಿಕೆ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ನಿರ್ಮಿಸಲು ಸೂಕ್ತವಾದ ಆಯ್ಕೆಯಾಗಿದೆ.

ಕಿರೋ ಮತ್ತು ಲ್ಯಾಂಗ್‌ಚೈನ್‌ನೊಂದಿಗೆ AI-ಚಾಲಿತ ಏಜೆಂಟ್‌ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು

ಕಿರೋ ಮತ್ತು ಲ್ಯಾಂಗ್‌ಚೈನ್‌ನ ಶಕ್ತಿಯನ್ನು ಪ್ರದರ್ಶಿಸಲು, CI/CD ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವ AI-ಚಾಲಿತ ಏಜೆಂಟ್ ಅನ್ನು ನಿರ್ಮಿಸುವ ಸರಳ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸೋಣ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, Git ರೆಪೊಸಿಟರಿಯೊಂದಿಗೆ ಸಂವಹನ ಮಾಡಬಹುದಾದ ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸಲು, ಕೋಡ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕ್ಲೌಡ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗೆ ನಿಯೋಜಿಸಲು ನಾವು Kiro ಅನ್ನು ಬಳಸುತ್ತೇವೆ.

CI/CD ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವ Kiro ಏಜೆಂಟ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುವ ಸರಳ ಕೋಡ್ ಬ್ಲಾಕ್ ಇಲ್ಲಿದೆ: ``ಹೆಬ್ಬಾವು ಆಮದು ಕಿರೋ ಲ್ಯಾಂಗ್‌ಚೈನ್ ಆಮದು LLAMA ನಿಂದ

ಏಜೆಂಟ್ = ಕಿರೋ. ಏಜೆಂಟ್( ಹೆಸರು="ci_cd_agent", ವಿವರಣೆ="ಆಟೋಮೇಟ್ಸ್ CI/CD ಪೈಪ್‌ಲೈನ್", ಕ್ರಮಗಳು=[ ಕಿರೋ.ಆಕ್ಷನ್( ಹೆಸರು="git_clone", ವಿವರಣೆ="Git ರೆಪೊಸಿಟರಿಯನ್ನು ಕ್ಲೋನ್ಸ್ ಮಾಡುತ್ತದೆ", ಕೋಡ್=""" ಆಮದು ಜಿಟ್ repo = git.Repo.clone("https://github.com/user/repo.git") """ ), ಕಿರೋ.ಆಕ್ಷನ್( ಹೆಸರು="ನಿರ್ಮಾಣ", ವಿವರಣೆ="ಕೋಡ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ", ಕೋಡ್=""" ಆಮದು ಉಪಪ್ರಕ್ರಿಯೆ subprocess.run(["ಮಾಡು", "ನಿರ್ಮಾಣ"]) """ ), ಕಿರೋ.ಆಕ್ಷನ್( ಹೆಸರು = "ಪರೀಕ್ಷೆ", ವಿವರಣೆ="ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸುತ್ತದೆ", ಕೋಡ್=""" ಆಮದು ಉಪಪ್ರಕ್ರಿಯೆ subprocess.run(["ಮಾಡು", "ಪರೀಕ್ಷೆ"]) """ ), ಕಿರೋ.ಆಕ್ಷನ್( ಹೆಸರು = "ನಿಯೋಜನೆ", ವಿವರಣೆ="ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ", ಕೋಡ್=""" ಆಮದು ಉಪಪ್ರಕ್ರಿಯೆ subprocess.run(["ಮಾಡು", "ನಿಯೋಜನೆ"]) """ ) ] )

LangChain LLAMA ಮಾದರಿಯನ್ನು ರಚಿಸಿ

ಲಾಮಾ = ಲಾಮಾ( ಹೆಸರು="ಲ್ಲಾಮಾ_ಮಾಡೆಲ್", ವಿವರಣೆ="ಭಾಷಾ ತಿಳುವಳಿಕೆಗಾಗಿ LLAMA ಮಾದರಿ", ಕೋಡ್=""" ಆಮದು ಲ್ಯಾಂಗ್‌ಚೈನ್ ಮಾದರಿ = langchain.LLAMA( ಹೆಸರು="ಲ್ಲಾಮಾ_ಮಾಡೆಲ್", ವಿವರಣೆ="ಭಾಷಾ ತಿಳುವಳಿಕೆಗಾಗಿ LLAMA ಮಾದರಿ", ಕೋಡ್=""" ಆಮದು ಲ್ಯಾಂಗ್‌ಚೈನ್ ಮಾದರಿ = langchain.LLAMA( ಹೆಸರು="ಲ್ಲಾಮಾ_ಮಾಡೆಲ್", ವಿವರಣೆ="ಭಾಷಾ ತಿಳುವಳಿಕೆಗಾಗಿ LLAMA ಮಾದರಿ", ಕೋಡ್=""" ಡೆಫ್ ಪ್ರಕ್ರಿಯೆ_ಪಠ್ಯ(ಪಠ್ಯ): # LLAMA ಮಾದರಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪಠ್ಯವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ ಪಠ್ಯ ಹಿಂತಿರುಗಿ """ ) """ ) """ )

LangChain LLAMA ಮಾದರಿಯನ್ನು ಬಳಸುವ Kiro ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸಿ

ಏಜೆಂಟ್ = ಕಿರೋ. ಏಜೆಂಟ್( ಹೆಸರು="ci_cd_agent", ವಿವರಣೆ="ಆಟೋಮೇಟ್ಸ್ CI/CD ಪೈಪ್‌ಲೈನ್", ಕ್ರಮಗಳು=[ ಕಿರೋ.ಆಕ್ಷನ್( ಹೆಸರು="git_clone", ವಿವರಣೆ="Git ರೆಪೊಸಿಟರಿಯನ್ನು ಕ್ಲೋನ್ಸ್ ಮಾಡುತ್ತದೆ", ಕೋಡ್=""" ಆಮದು ಜಿಟ್ repo = git.Repo.clone("https://github.com/user/repo.git") """ ), ಕಿರೋ.ಆಕ್ಷನ್( ಹೆಸರು="ನಿರ್ಮಾಣ", ವಿವರಣೆ="ಕೋಡ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ", ಕೋಡ್=""" ಆಮದು ಉಪಪ್ರಕ್ರಿಯೆ subprocess.run(["ಮಾಡು", "ನಿರ್ಮಾಣ"]) """ ), ಕಿರೋ.ಆಕ್ಷನ್( ಹೆಸರು = "ಪರೀಕ್ಷೆ", ವಿವರಣೆ="ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸುತ್ತದೆ", ಕೋಡ್=""" ಆಮದು ಉಪಪ್ರಕ್ರಿಯೆ subprocess.run(["ಮಾಡು", "ಪರೀಕ್ಷೆ"]) """ ), ಕಿರೋ.ಆಕ್ಷನ್( ಹೆಸರು = "ನಿಯೋಜನೆ", ವಿವರಣೆ="ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ", ಕೋಡ್=""" ಆಮದು ಉಪಪ್ರಕ್ರಿಯೆ subprocess.run(["ಮಾಡು", "ನಿಯೋಜನೆ"]) """ ) ], language_model = ಲಾಮಾ )

ಏಜೆಂಟ್ ಅನ್ನು ರನ್ ಮಾಡಿ

agent.run()

ಭಾಷಾ ತಿಳುವಳಿಕೆಗಾಗಿ LangChain LLAMA ಮಾದರಿಯನ್ನು ಬಳಸಿಕೊಂಡು CI/CD ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವ Kiro ಏಜೆಂಟ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದನ್ನು ಈ ಕೋಡ್ ಬ್ಲಾಕ್ ತೋರಿಸುತ್ತದೆ. ಏಜೆಂಟ್ Git ರೆಪೊಸಿಟರಿಯೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಬಹುದು, ಕೋಡ್ ಅನ್ನು ನಿರ್ಮಿಸಬಹುದು ಮತ್ತು ಪರೀಕ್ಷಿಸಬಹುದು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕ್ಲೌಡ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗೆ ನಿಯೋಜಿಸಬಹುದು.

**ಟಾಪ್ 5-10 ಹೆಚ್ಚು ಬಳಸಿದ ಆಜ್ಞೆಗಳು/ತುಣುಕುಗಳು**

Kiro ಮತ್ತು LangChain ಗಾಗಿ ಹೆಚ್ಚು ಬಳಸಿದ 5-10 ಕಮಾಂಡ್‌ಗಳು/ತುಣುಕುಗಳು ಇಲ್ಲಿವೆ:

1. `kiroutil init`: ಹೊಸ Kiro ಯೋಜನೆಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.
2. `ಕಿರೂಟಿಲ್ ಬಿಲ್ಡ್`: ಕಿರೋ ಏಜೆಂಟ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ.
3. `langchain init`: ಹೊಸ LangChain ಯೋಜನೆಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.
4. `ಲ್ಯಾಂಗ್‌ಚೈನ್ ಬಿಲ್ಡ್`: ಲ್ಯಾಂಗ್‌ಚೈನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ.
5. `ಕಿರೂಟಿಲ್ ರನ್`: ಕಿರೋ ಏಜೆಂಟ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ.
6. `ಲ್ಯಾಂಗ್‌ಚೈನ್ ಟೆಸ್ಟ್`: ಲ್ಯಾಂಗ್‌ಚೈನ್ ಮಾದರಿಯನ್ನು ಪರೀಕ್ಷಿಸುತ್ತದೆ.
7. `kiroutil deploy`: ಕ್ಲೌಡ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗೆ Kiro ಏಜೆಂಟ್ ಅನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ.
8. `ಲ್ಯಾಂಗ್‌ಚೈನ್ ಮೌಲ್ಯಮಾಪನ': ಲ್ಯಾಂಗ್‌ಚೈನ್ ಮಾದರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ.
9. `ಕಿರೂಟಿಲ್ ಡೀಬಗ್`: ಕಿರೋ ಏಜೆಂಟ್ ಅನ್ನು ಡೀಬಗ್ ಮಾಡುತ್ತದೆ.
10. `ಲ್ಯಾಂಗ್‌ಚೈನ್ ದೃಶ್ಯೀಕರಿಸು`: ಲ್ಯಾಂಗ್‌ಚೈನ್ ಮಾದರಿಯನ್ನು ದೃಶ್ಯೀಕರಿಸುತ್ತದೆ.

**ದೃಶ್ಯೀಕರಣ**

Chart.js ಅನ್ನು ಬಳಸಿಕೊಂಡು Kiro ಮತ್ತು LangChain ಆರ್ಕಿಟೆಕ್ಚರ್‌ನ ದೃಶ್ಯೀಕರಣ ಇಲ್ಲಿದೆ:
```json
{
  "ಪ್ರಕಾರ": "ಬಾರ್",
  "ಡೇಟಾ": {
    "ಲೇಬಲ್‌ಗಳು": ["ಕಿರೋ", "ಲ್ಯಾಂಗ್‌ಚೈನ್"],
    "ಡೇಟಾಸೆಟ್‌ಗಳು": [
      {
        "ಲೇಬಲ್": "ಆರ್ಕಿಟೆಕ್ಚರ್",
        "ಡೇಟಾ": [100, 80],
        "backgroundColor": ["#4CAF50", "#FF9800"]
      }
    ]
  },
  "ಆಯ್ಕೆಗಳು": {
    "ಶೀರ್ಷಿಕೆ": {
      "ಪ್ರದರ್ಶನ": ನಿಜ,
      "ಪಠ್ಯ": "ಕಿರೋ ಮತ್ತು ಲ್ಯಾಂಗ್‌ಚೈನ್ ಆರ್ಕಿಟೆಕ್ಚರ್"
    },
    "ದಂತಕಥೆ": {
      "ಪ್ರದರ್ಶನ": ನಿಜ
    }
  }
}

ಈ ದೃಶ್ಯೀಕರಣವು ಕಿರೋ ಮತ್ತು ಲ್ಯಾಂಗ್‌ಚೈನ್‌ನ ಉನ್ನತ ಮಟ್ಟದ ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಅವುಗಳ ಸಾಮರ್ಥ್ಯ ಮತ್ತು ದೌರ್ಬಲ್ಯಗಳನ್ನು ಎತ್ತಿ ತೋರಿಸುತ್ತದೆ.

** ತೀರ್ಮಾನ **

ಈ ಲೇಖನದಲ್ಲಿ, ನಾವು Kiro ಮತ್ತು LangChain ಬಳಸಿಕೊಂಡು DevOps ಆಟೊಮೇಷನ್‌ಗಾಗಿ ಏಜೆಂಟ್ AI ಯ ಶಕ್ತಿಯನ್ನು ಅನ್ವೇಷಿಸಿದ್ದೇವೆ. ಈ ಅತ್ಯಾಧುನಿಕ ಚೌಕಟ್ಟುಗಳನ್ನು ನಿಯಂತ್ರಿಸುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಬುದ್ಧಿವಂತ ಏಜೆಂಟ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು ಅದು CI/CD ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಬಹುದು ಮತ್ತು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಬಹುದು, ಸಾಫ್ಟ್‌ವೇರ್ ವಿತರಣಾ ದಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ ಮತ್ತು ದೋಷಗಳ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. Kiro ಮತ್ತು LangChain ನೊಂದಿಗೆ, ಅಭಿವರ್ಧಕರು ಕಸ್ಟಮ್ NLP ಮತ್ತು ಭಾಷಾ ತಿಳುವಳಿಕೆ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ವಿವಿಧ ವ್ಯವಸ್ಥೆಗಳು, ಸೇವೆಗಳು ಮತ್ತು ಡೇಟಾ ಮೂಲಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಬಹುದು. ಭಾಷೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು LangChain LLAMA ಮಾದರಿಯನ್ನು ಬಳಸಿಕೊಂಡು CI/CD ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವ Kiro ಏಜೆಂಟ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುವ ಸರಳ ಕೋಡ್ ಬ್ಲಾಕ್ ಅನ್ನು ಸಹ ನಾವು ಒದಗಿಸಿದ್ದೇವೆ.