ಪರಿಚಯ

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

AI-ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ನ ಸವಾಲುಗಳು

AI-ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಸಾಫ್ಟ್‌ವೇರ್ ಎಂಜಿನಿಯರ್‌ಗಳು ಮತ್ತು DevOps ತಂಡಗಳಿಗೆ ಅನನ್ಯ ಸವಾಲುಗಳನ್ನು ಒಡ್ಡುತ್ತವೆ. ಕೆಲವು ಪ್ರಮುಖ ಸವಾಲುಗಳು ಸೇರಿವೆ:

• ಸ್ಕೇಲೆಬಿಲಿಟಿ: AI ಮಾದರಿಗಳಿಗೆ ಗಮನಾರ್ಹವಾದ ಕಂಪ್ಯೂಟೇಶನಲ್ ಸಂಪನ್ಮೂಲಗಳ ಅಗತ್ಯವಿರುತ್ತದೆ, ಇದು ಉತ್ಪಾದನಾ ಪರಿಸರದಲ್ಲಿ ಸ್ಕೇಲೆಬಿಲಿಟಿ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.
• ಭದ್ರತೆ: ಡೇಟಾ ವಿಷಕಾರಿ ಮತ್ತು ಮಾದರಿ ವಿಲೋಮ ದಾಳಿಗಳಂತಹ ದಾಳಿಗಳಿಗೆ AI ಮಾದರಿಗಳು ಗುರಿಯಾಗಬಹುದು.
• ಏಕೀಕರಣ: AI ಮಾದರಿಗಳನ್ನು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಸಾಫ್ಟ್‌ವೇರ್ ಸಿಸ್ಟಮ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸುವ ಅಗತ್ಯವಿದೆ, ಇದು ಸಂಕೀರ್ಣ ಕಾರ್ಯವಾಗಿದೆ.
• ಮೇಲ್ವಿಚಾರಣೆ ಮತ್ತು ನಿರ್ವಹಣೆ: AI ಮಾದರಿಗಳು ನಿಖರ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿ ಉಳಿಯುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿರಂತರ ಮೇಲ್ವಿಚಾರಣೆ ಮತ್ತು ನಿರ್ವಹಣೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ.

ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಪರಿಕರಗಳು: DSPy ಮತ್ತು LangChain

DSPy ಮತ್ತು LangChain ನಂತಹ ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಉಪಕರಣಗಳು AI ಏಜೆಂಟ್‌ಗಳ ಏಕೀಕರಣವನ್ನು DevOps ಪೈಪ್‌ಲೈನ್‌ಗಳಿಗೆ ಸಕ್ರಿಯಗೊಳಿಸುವ ಮೂಲಕ ಈ ಸವಾಲುಗಳಿಗೆ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಈ ಉಪಕರಣಗಳು AI ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಲು, ನಿಯೋಜಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಚೌಕಟ್ಟನ್ನು ಒದಗಿಸುತ್ತವೆ, AI- ಚಾಲಿತ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಸುರಕ್ಷಿತ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಖಾತ್ರಿಪಡಿಸುತ್ತದೆ.

ಡಿಎಸ್ಪಿ

DSPy ಎಂಬುದು ಪೈಥಾನ್‌ನ ಮೇಲ್ಭಾಗದಲ್ಲಿ ನಿರ್ಮಿಸಲಾದ ಓಪನ್ ಸೋರ್ಸ್ ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಸಾಧನವಾಗಿದೆ. ಇದು AI ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಲು, ನಿಯೋಜಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸರಳ ಮತ್ತು ಅರ್ಥಗರ್ಭಿತ API ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. DSPy TensorFlow, PyTorch, ಮತ್ತು scikit-learn ಸೇರಿದಂತೆ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ AI ಚೌಕಟ್ಟುಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ.

ಲ್ಯಾಂಗ್‌ಚೈನ್

ಲ್ಯಾಂಗ್‌ಚೈನ್ ಮತ್ತೊಂದು ಓಪನ್ ಸೋರ್ಸ್ ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಸಾಧನವಾಗಿದ್ದು ಅದು AI ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಲು, ನಿಯೋಜಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಚೌಕಟ್ಟನ್ನು ಒದಗಿಸುತ್ತದೆ. ಲ್ಯಾಂಗ್‌ಚೈನ್ ಅನ್ನು ರಸ್ಟ್‌ನ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ ಮತ್ತು AI ಏಜೆಂಟ್‌ಗಳನ್ನು DevOps ಪೈಪ್‌ಲೈನ್‌ಗಳಿಗೆ ಸಂಯೋಜಿಸಲು ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆಯ API ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.

DSPy ಯೊಂದಿಗೆ ಸುರಕ್ಷಿತ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ AI-ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು

ಈ ವಿಭಾಗದಲ್ಲಿ, DSPy ಯೊಂದಿಗೆ ಸುರಕ್ಷಿತ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ AI- ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸರಳ ಉದಾಹರಣೆಯನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ.

ಉದಾಹರಣೆ: DSPy ಯೊಂದಿಗೆ ಸರಳ AI ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸುವುದು

DSPy ಬಳಸಿಕೊಂಡು ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸುವ ಸರಳ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸೋಣ. ಲೀನಿಯರ್ ರಿಗ್ರೆಷನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಲು ನಾವು ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುತ್ತೇವೆ.

``ಹೆಬ್ಬಾವು ಡಿಎಸ್ಪಿ ಎಂದು ಡಿಎಸ್ಪಿ ಆಮದು ಮಾಡಿ sklearn.linear_model ಆಮದು LinearRegression ನಿಂದ sklearn.datasets ಆಮದು load_diabetes ನಿಂದ

ಮಧುಮೇಹ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಿ

ಡೇಟಾಸೆಟ್ = ಲೋಡ್_ಡಯಾಬಿಟಿಸ್()

ಡೇಟಾಸೆಟ್ ಅನ್ನು ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಸೆಟ್‌ಗಳಾಗಿ ವಿಭಜಿಸಿ

X_train, X_test, y_train, y_test = dsp.split_dataset(dataset.data, dataset.target, test_size=0.2)

ರೇಖೀಯ ಹಿಂಜರಿತ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ

ಮಾದರಿ = ಲೀನಿಯರ್ ರಿಗ್ರೆಷನ್()

ತರಬೇತಿ ಡೇಟಾದಲ್ಲಿ ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಮಾಡಿ

model.fit(X_train, y_train)

ಪರೀಕ್ಷಾ ಡೇಟಾದಲ್ಲಿ ಮಾದರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ

ನಿಖರತೆ = model.ಸ್ಕೋರ್(X_test, y_test) ಮುದ್ರಣ(f"ಮಾದರಿ ನಿಖರತೆ: {ನಿಖರತೆ:.2f}")

ಈ ಕೋಡ್ ಬ್ಲಾಕ್ DSPy ಬಳಸಿಕೊಂಡು ಸರಳವಾದ ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಯನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ. ನಾವು ಮಧುಮೇಹ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುತ್ತೇವೆ, ಅದನ್ನು ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಸೆಟ್‌ಗಳಾಗಿ ವಿಭಜಿಸುತ್ತೇವೆ, ರೇಖಾತ್ಮಕ ಹಿಂಜರಿತ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸುತ್ತೇವೆ, ತರಬೇತಿ ಡೇಟಾದಲ್ಲಿ ತರಬೇತಿ ನೀಡುತ್ತೇವೆ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾದಲ್ಲಿ ಅದರ ನಿಖರತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತೇವೆ.

## ಲ್ಯಾಂಗ್‌ಚೈನ್‌ನೊಂದಿಗೆ ಸುರಕ್ಷಿತ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ AI-ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು

ಈ ವಿಭಾಗದಲ್ಲಿ, ಲ್ಯಾಂಗ್‌ಚೈನ್‌ನೊಂದಿಗೆ ಸುರಕ್ಷಿತ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ AI-ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸರಳ ಉದಾಹರಣೆಯನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ.

### ಉದಾಹರಣೆ: ಲ್ಯಾಂಗ್‌ಚೈನ್‌ನೊಂದಿಗೆ ಸರಳ AI ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸುವುದು

ಲ್ಯಾಂಗ್‌ಚೈನ್ ಬಳಸಿ ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸುವ ಸರಳ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸೋಣ. ನ್ಯೂರಲ್ ನೆಟ್‌ವರ್ಕ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಲು ನಾವು ಟೆನ್ಸರ್‌ಫ್ಲೋ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುತ್ತೇವೆ.

```ತುಕ್ಕು
ಲ್ಯಾಂಗ್ಚೈನ್ ಅನ್ನು ಎಲ್ಸಿ ಆಗಿ ಬಳಸಿ;
ಟೆನ್ಸರ್‌ಫ್ಲೋ ಬಳಸಿ:: ಮುನ್ನುಡಿ::*;

// ಸರಳವಾದ ನರಮಂಡಲದ ಮಾದರಿಯನ್ನು ವಿವರಿಸಿ
fn ಮಾದರಿ(ಇನ್‌ಪುಟ್: &ಟೆನ್ಸರ್) -> ಟೆನ್ಸರ್ {
    output = input.matmul(&Tensor::new(1, 1));
    ಔಟ್ಪುಟ್
}

// ಲ್ಯಾಂಗ್‌ಚೈನ್ ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸಿ
ಏಜೆಂಟ್ = lc:: ಏಜೆಂಟ್:: ಹೊಸ (ಮಾದರಿ);

// ಡೇಟಾಸೆಟ್ ಅನ್ನು ವಿವರಿಸಿ
ಲೆಟ್ ಡೇಟಾಸೆಟ್ = ಎಲ್ಸಿ::ಡೇಟಾಸೆಟ್::ಹೊಸ(ವೆಕ್![
    lc::ಉದಾಹರಣೆ::ಹೊಸ(vec![1.0, 2.0], vec![3.0]),
    lc::ಉದಾಹರಣೆ::ಹೊಸ(vec![4.0, 5.0], vec![6.0]),
]);

// ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಮಾಡಿ
agent.train(&ಡೇಟಾಸೆಟ್);

// ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಮಾದರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ
ಲೆಟ್ ನಿಖರತೆ = agent.evaluate(&dataset);
println!("ಮಾದರಿ ನಿಖರತೆ: {}", ನಿಖರತೆ);

ಈ ಕೋಡ್ ಬ್ಲಾಕ್ ಲ್ಯಾಂಗ್‌ಚೈನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸರಳವಾದ ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಯನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ. ನಾವು ಸರಳವಾದ ನ್ಯೂರಲ್ ನೆಟ್‌ವರ್ಕ್ ಮಾದರಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ, ಲ್ಯಾಂಗ್‌ಚೈನ್ ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ, ಡೇಟಾಸೆಟ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ, ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಅದರ ನಿಖರತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತೇವೆ.

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

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

ಡಿಎಸ್ಪಿ

• dsp.split_dataset(ಡೇಟಾ, ಗುರಿ, test_size=0.2): ಡೇಟಾಸೆಟ್ ಅನ್ನು ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಸೆಟ್‌ಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ.
• dsp.build_model(model_name, model_params): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಮಾದರಿ ಹೆಸರು ಮತ್ತು ನಿಯತಾಂಕಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ.
• dsp.train_model(ಮಾದರಿ, ಡೇಟಾ): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೇಟಾದಲ್ಲಿ ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಮಾಡುತ್ತದೆ.
• dsp.evaluate_model(ಮಾದರಿ, ಡೇಟಾ): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೇಟಾದಲ್ಲಿ ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ.
• dsp.deploy_model(model, server_url): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸರ್ವರ್ URL ಗೆ ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಯನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ.

ಲ್ಯಾಂಗ್‌ಚೈನ್

• lc:: ಏಜೆಂಟ್::ಹೊಸ(ಮಾದರಿ): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಮಾದರಿಯನ್ನು ಬಳಸಿಕೊಂಡು LangChain ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
• lc::Dataset::new(ಉದಾಹರಣೆಗಳು): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಉದಾಹರಣೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು LangChain ಡೇಟಾಸೆಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
• lc:: ರೈಲು(ಏಜೆಂಟ್, ಡೇಟಾಸೆಟ್): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ LangChain ಏಜೆಂಟ್‌ಗೆ ತರಬೇತಿ ನೀಡುತ್ತದೆ.
• lc:: ಮೌಲ್ಯಮಾಪನ (ಏಜೆಂಟ್, ಡೇಟಾಸೆಟ್): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ LangChain ಏಜೆಂಟ್‌ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ.
• lc::deploy(agent, server_url): LangChain ಏಜೆಂಟ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸರ್ವರ್ URL ಗೆ ನಿಯೋಜಿಸುತ್ತದೆ.

ದೃಶ್ಯೀಕರಣ

Chart.js ಅನ್ನು ಬಳಸಿಕೊಂಡು AI ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ನ ಸರಳ ದೃಶ್ಯೀಕರಣ ಇಲ್ಲಿದೆ:

const ctx = document.getElementById('myChart').getContext('2d');
const ಚಾರ್ಟ್ = ಹೊಸ ಚಾರ್ಟ್(ctx, {
    ಪ್ರಕಾರ: 'ಬಾರ್',
    ಡೇಟಾ: {
        ಲೇಬಲ್‌ಗಳು: ['ತರಬೇತಿ ಸಮಯ', 'ಅನುಮಾನ ಸಮಯ', 'ಮಾದರಿ ನಿಖರತೆ'],
        ಡೇಟಾಸೆಟ್‌ಗಳು: [{
            ಲೇಬಲ್: 'DSPy',
            ಡೇಟಾ: [10, 5, 90],
            ಹಿನ್ನೆಲೆ ಬಣ್ಣ: 'rgba(255, 99, 132, 0.2)',
            ಗಡಿವರ್ಣ: 'rgba(255, 99, 132, 1)',
            ಗಡಿ ಅಗಲ: 1
        }, {
            ಲೇಬಲ್: 'ಲ್ಯಾಂಗ್‌ಚೈನ್',
            ಡೇಟಾ: [8, 6, 92],
            ಹಿನ್ನೆಲೆ ಬಣ್ಣ: 'rgba(54, 162, 235, 0.2)',
            ಗಡಿವರ್ಣ: 'rgba(54, 162, 235, 1)',
            ಗಡಿ ಅಗಲ: 1
        }]
    },
    ಆಯ್ಕೆಗಳು: {
        ಮಾಪಕಗಳು: {
            ವೈ: {
                ಆರಂಭ ಶೂನ್ಯ: ನಿಜ
            }
        }
    }
});

ಈ ಕೋಡ್ ಬ್ಲಾಕ್ DSPy ಮತ್ತು LangChain ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ದೃಶ್ಯೀಕರಿಸಲು Chart.js ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸರಳವಾದ ಬಾರ್ ಚಾರ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.

ತೀರ್ಮಾನ

ಈ ಲೇಖನದಲ್ಲಿ, AI ಏಜೆಂಟ್‌ಗಳನ್ನು DevOps ಪೈಪ್‌ಲೈನ್‌ಗಳಲ್ಲಿ ಸಂಯೋಜಿಸಲು DSPy ಮತ್ತು LangChain ನಂತಹ ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಪರಿಕರಗಳನ್ನು ಬಳಸುವುದರ ಮೇಲೆ ನಿರ್ದಿಷ್ಟ ಒತ್ತು ನೀಡುವ ಮೂಲಕ AI, ಸಾಫ್ಟ್‌ವೇರ್ ಎಂಜಿನಿಯರಿಂಗ್ ಮತ್ತು DevOps ನ ಛೇದಕವನ್ನು ನಾವು ಅನ್ವೇಷಿಸಿದ್ದೇವೆ. DSPy ಮತ್ತು LangChain ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸುರಕ್ಷಿತ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ AI- ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು ಎಂಬುದನ್ನು ನಾವು ಪ್ರದರ್ಶಿಸಿದ್ದೇವೆ ಮತ್ತು ಪ್ರತಿ ಉಪಕರಣವನ್ನು ಬಳಸಿಕೊಂಡು ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸುವ ಸರಳ ಉದಾಹರಣೆಯನ್ನು ಒದಗಿಸಿದ್ದೇವೆ. ನಾವು ಪ್ರತಿ ಟೂಲ್‌ಗೆ ಟಾಪ್ 5-10 ಕಮಾಂಡ್‌ಗಳು/ತುಣುಕುಗಳನ್ನು ಒದಗಿಸಿದ್ದೇವೆ ಮತ್ತು Chart.js ಅನ್ನು ಬಳಸಿಕೊಂಡು AI- ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ನ ಸರಳ ದೃಶ್ಯೀಕರಣವನ್ನು ಸಹ ಒದಗಿಸಿದ್ದೇವೆ.