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

ಪರಿಚಯ

ಸಾಫ್ಟ್‌ವೇರ್ ವ್ಯವಸ್ಥೆಗಳ ಹೆಚ್ಚುತ್ತಿರುವ ಸಂಕೀರ್ಣತೆಯು ಪರೀಕ್ಷಾ ಯಾಂತ್ರೀಕರಣವನ್ನು ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯ ನಿರ್ಣಾಯಕ ಅಂಶವನ್ನಾಗಿ ಮಾಡಿದೆ. ಸಾಂಪ್ರದಾಯಿಕ ಪರೀಕ್ಷಾ ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಚೌಕಟ್ಟುಗಳು ಸ್ಕ್ರಿಪ್ಟೆಡ್ ವಿಧಾನಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ, ಇದು ಸುಲಭವಾಗಿ ಮತ್ತು ನಿರ್ವಹಿಸಲು ಕಷ್ಟಕರವಾಗಿರುತ್ತದೆ. ಇತ್ತೀಚಿನ ವರ್ಷಗಳಲ್ಲಿ, Agentic AI ಮತ್ತು ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಪರಿಕರಗಳ ಹೊರಹೊಮ್ಮುವಿಕೆಯು ಸಂಕೀರ್ಣ ಪರೀಕ್ಷಾ ಸನ್ನಿವೇಶಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಹೊಸ ಸಾಧ್ಯತೆಗಳನ್ನು ತೆರೆದಿದೆ. ಈ ಲೇಖನದಲ್ಲಿ, ಲ್ಯಾಂಗ್‌ಚೈನ್ ಮತ್ತು ಡಿಎಸ್‌ಪಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಸಂಕೀರ್ಣ ಪರೀಕ್ಷಾ ಸನ್ನಿವೇಶಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ನಾವು ಏಜೆಂಟ್ ಎಐ, ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಪರಿಕರಗಳು ಮತ್ತು ಸಾಫ್ಟ್‌ವೇರ್ ಎಂಜಿನಿಯರಿಂಗ್‌ನ ಛೇದಕವನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ.

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

ಏಜೆಂಟಿಕ್ AI ಎನ್ನುವುದು ಒಂದು ರೀತಿಯ ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಇದನ್ನು ಬಳಕೆದಾರರು ಅಥವಾ ಸಿಸ್ಟಮ್ ಪರವಾಗಿ ಕ್ರಮಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಏಜೆಂಟಿಕ್ AI ವ್ಯವಸ್ಥೆಗಳು ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು, ಅನುಭವದಿಂದ ಕಲಿಯಲು ಮತ್ತು ಹೊಸ ಸನ್ನಿವೇಶಗಳಿಗೆ ಹೊಂದಿಕೊಳ್ಳಲು ಸಮರ್ಥವಾಗಿವೆ. ಪರೀಕ್ಷಾ ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಸಂದರ್ಭದಲ್ಲಿ, ಬಳಕೆದಾರರ ಸಂವಹನಗಳನ್ನು ಅನುಕರಿಸುವ ಮೂಲಕ, ಪರೀಕ್ಷಾ ಡೇಟಾದ ಆಧಾರದ ಮೇಲೆ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದು ಮತ್ತು ಬದಲಾಗುತ್ತಿರುವ ಪರೀಕ್ಷಾ ಪರಿಸ್ಥಿತಿಗಳಿಗೆ ಹೊಂದಿಕೊಳ್ಳುವ ಮೂಲಕ ಸಂಕೀರ್ಣ ಪರೀಕ್ಷಾ ಸನ್ನಿವೇಶಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು Agentic AI ಅನ್ನು ಬಳಸಬಹುದು.

ಲ್ಯಾಂಗ್‌ಚೈನ್ ಎಂದರೇನು?

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

DSPy ಎಂದರೇನು?

DSPy ಎಂಬುದು ಪೈಥಾನ್ ಲೈಬ್ರರಿಯಾಗಿದ್ದು ಅದು AI ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ನಿಯೋಜಿಸಲು ಉಪಕರಣಗಳ ಗುಂಪನ್ನು ಒದಗಿಸುತ್ತದೆ. DSPy ಅನ್ನು LangChain ನೊಂದಿಗೆ ಮನಬಂದಂತೆ ಕೆಲಸ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಡೇಟಾ ಸಂಸ್ಕರಣೆ, ಯಂತ್ರ ಕಲಿಕೆ ಮತ್ತು ಆಳವಾದ ಕಲಿಕೆ ಸೇರಿದಂತೆ ಹಲವಾರು ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

** ಡಿಟರ್ಮಿನಿಸ್ಟಿಕ್ ಟೆಸ್ಟ್ ಆಟೊಮೇಷನ್‌ನಲ್ಲಿ ಏಜೆಂಟ್ AI ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು**

ನಿರ್ಣಾಯಕ ಪರೀಕ್ಷಾ ಯಾಂತ್ರೀಕರಣದಲ್ಲಿ Agentic AI ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, ಬಳಕೆದಾರರ ಸಂವಹನಗಳನ್ನು ಅನುಕರಿಸುವ, ಪರೀಕ್ಷಾ ಡೇಟಾದ ಆಧಾರದ ಮೇಲೆ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು ಬದಲಾಗುತ್ತಿರುವ ಪರೀಕ್ಷಾ ಪರಿಸ್ಥಿತಿಗಳಿಗೆ ಹೊಂದಿಕೊಳ್ಳುವ ಪರೀಕ್ಷಾ ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಚೌಕಟ್ಟನ್ನು ನಿರ್ಮಿಸಲು ನಾವು LangChain ಮತ್ತು DSPy ಅನ್ನು ಬಳಸಬಹುದು.

ಪರೀಕ್ಷಾ ಸನ್ನಿವೇಶವನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ನಾವು LangChain ಮತ್ತು DSPy ಅನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದರ ಸರಳ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ: ``ಹೆಬ್ಬಾವು ಆಮದು ಲ್ಯಾಂಗ್‌ಚೈನ್ langchain.chains ನಿಂದ LLMCchain ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ langchain.llms ನಿಂದ DSPyLLM ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ

test_scenario = { "user_input": "ಲಾಗಿನ್", "expected_output": "ಲಾಗಿನ್ ಯಶಸ್ವಿಯಾಗಿದೆ" }

ಏಜೆಂಟ್ AI ಏಜೆಂಟ್ ಅನ್ನು ವಿವರಿಸಿ

ಏಜೆಂಟ್ = LLMCchain( llm=DSPyLLM(), input_type="text", output_type="text" )

ಪರೀಕ್ಷಾ ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಕಾರ್ಯವನ್ನು ವಿವರಿಸಿ

ಡೆಫ್ ಟೆಸ್ಟ್_ಆಟೊಮೇಷನ್(ಪರೀಕ್ಷೆ_ಸನ್ನಿವೇಶ): # ಬಳಕೆದಾರರ ಸಂವಹನವನ್ನು ಅನುಕರಿಸಿ user_input = test_scenario["user_input"] # ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ಆಧರಿಸಿ ನಿರ್ಧಾರ ತೆಗೆದುಕೊಳ್ಳಿ ನಿರ್ಧಾರ = agent.run(user_input) # ಬದಲಾಗುತ್ತಿರುವ ಪರೀಕ್ಷಾ ಪರಿಸ್ಥಿತಿಗಳಿಗೆ ಹೊಂದಿಕೊಳ್ಳಿ ನಿರ್ಧಾರ == "ಲಾಗಿನ್ ಯಶಸ್ವಿಯಾಗಿದ್ದರೆ": ಮುದ್ರಣ ("ಪರೀಕ್ಷೆ ಉತ್ತೀರ್ಣ") ಬೇರೆ: ಮುದ್ರಣ ("ಪರೀಕ್ಷೆ ವಿಫಲವಾಗಿದೆ")

ಪರೀಕ್ಷಾ ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಕಾರ್ಯವನ್ನು ರನ್ ಮಾಡಿ

test_automation(test_scenario)

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

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

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

1. `langchain.LLMCchain(llm=DSPyLLM())`: LangChain ಮತ್ತು DSPy ಬಳಸಿಕೊಂಡು ಏಜೆಂಟ್ AI ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
2. `DSPyLLM()`: DSPy LLM (ದೊಡ್ಡ ಭಾಷೆಯ ಮಾದರಿ) ನಿದರ್ಶನವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.
3. `LLMCchain(input_type="text", output_type="text")`: ಪಠ್ಯ ಇನ್‌ಪುಟ್ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಪ್ರಕಾರಗಳೊಂದಿಗೆ Agentic AI ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
4. `agent.run(user_input)`: ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್‌ನೊಂದಿಗೆ Agentic AI ಏಜೆಂಟ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ.
5. `test_scenario = {"user_input": "login", "expected_output": "login successful"}`: ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಮತ್ತು ನಿರೀಕ್ಷಿತ ಔಟ್‌ಪುಟ್‌ನೊಂದಿಗೆ ಪರೀಕ್ಷಾ ಸನ್ನಿವೇಶವನ್ನು ವಿವರಿಸುತ್ತದೆ.
6. `langchain.chains.LLMCchain(llm=DSPyLLM())`: LangChain ಮತ್ತು DSPy ಅನ್ನು ಬಳಸಿಕೊಂಡು ಏಜೆಂಟ್ AI ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
7. `DSPyLLM().predict(user_input)`: ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್‌ನೊಂದಿಗೆ DSPy LLM ನ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಊಹಿಸುತ್ತದೆ.
8. `LLMCchain(input_type="text", output_type="text").run(user_input)`: ಪಠ್ಯ ಇನ್‌ಪುಟ್ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಪ್ರಕಾರಗಳೊಂದಿಗೆ Agentic AI ಏಜೆಂಟ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ.
9. `test_automation(test_scenario)`: ಪರೀಕ್ಷಾ ಸನ್ನಿವೇಶದೊಂದಿಗೆ ಪರೀಕ್ಷಾ ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಕಾರ್ಯವನ್ನು ರನ್ ಮಾಡುತ್ತದೆ.
10. `langchain.chains.LLMCchain(llm=DSPyLLM()).run(user_input)`: ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್‌ನೊಂದಿಗೆ Agentic AI ಏಜೆಂಟ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ.

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

Chart.js ಅನ್ನು ಬಳಸಿಕೊಂಡು ಏಜೆಂಟ್ AI ಏಜೆಂಟ್‌ನ ದೃಶ್ಯೀಕರಣ ಇಲ್ಲಿದೆ:
```json
{
  "ಪ್ರಕಾರ": "ಬಾರ್",
  "ಡೇಟಾ": {
    "ಲೇಬಲ್‌ಗಳು": ["ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್", "ನಿರ್ಧಾರ", "ಹೊಂದಾಣಿಕೆ"],
    "ಡೇಟಾಸೆಟ್‌ಗಳು": [
      {
        "label": "Agentic AI ಏಜೆಂಟ್",
        "ಡೇಟಾ": [10, 20, 30],
        "backgroundColor": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        "ಬಾರ್ಡರ್ ಅಗಲ": 1
      }
    ]
  },
  "ಆಯ್ಕೆಗಳು": {
    "ಶೀರ್ಷಿಕೆ": {
      "ಪ್ರದರ್ಶನ": ನಿಜ,
      "ಪಠ್ಯ": "ಏಜೆಂಟಿಕ್ AI ಏಜೆಂಟ್"
    },
    "ಮಾಪಕಗಳು": {
      "yAxes": [
        {
          "ಉಣ್ಣಿ": {
            "beginAtZero": ನಿಜ
          }
        }
      ]
    }
  }
}

ಈ ದೃಶ್ಯೀಕರಣವು ಬಳಕೆದಾರರ ಸಂವಹನಗಳನ್ನು ಅನುಕರಿಸುವಲ್ಲಿ, ಪರೀಕ್ಷಾ ಡೇಟಾದ ಆಧಾರದ ಮೇಲೆ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದು ಮತ್ತು ಬದಲಾಗುತ್ತಿರುವ ಪರೀಕ್ಷಾ ಪರಿಸ್ಥಿತಿಗಳಿಗೆ ಹೊಂದಿಕೊಳ್ಳುವಲ್ಲಿ ಏಜೆಂಟ್ AI ಏಜೆಂಟ್‌ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ತೋರಿಸುತ್ತದೆ.

** ತೀರ್ಮಾನ **

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