** აგენტური AI-ის დანერგვა დეტერმინისტული ტესტის ავტომატიზაციაში LangChain-ით და DSPy-ით**

შესავალი

პროგრამული სისტემების მზარდმა სირთულემ ტესტის ავტომატიზაცია პროგრამული უზრუნველყოფის განვითარების გადამწყვეტ ასპექტად აქცია. ტესტის ავტომატიზაციის ტრადიციული ჩარჩოები ეყრდნობა სკრიპტულ მიდგომებს, რომლებიც შეიძლება იყოს მყიფე და ძნელი შესანარჩუნებლად. ბოლო წლებში აგენტური AI და საორკესტრო ინსტრუმენტების გამოჩენამ გახსნა ახალი შესაძლებლობები რთული ტესტის სცენარების ავტომატიზაციისთვის. ამ სტატიაში ჩვენ შევისწავლით აგენტური AI, ორკესტრირების ხელსაწყოების და პროგრამული ინჟინერიის კვეთას რთული ტესტის სცენარების ავტომატიზაციისთვის LangChain-ისა და DSPy-ის გამოყენებით.

** რა არის აგენტური AI?**

აგენტური AI ეხება ხელოვნური ინტელექტის ტიპს, რომელიც შექმნილია მომხმარებლის ან სისტემის სახელით მოქმედებების განსახორციელებლად. აგენტურ AI სისტემებს შეუძლიათ გადაწყვეტილების მიღება, გამოცდილებიდან სწავლა და ახალ სიტუაციებთან ადაპტაცია. ტესტის ავტომატიზაციის კონტექსტში, აგენტური AI შეიძლება გამოყენებულ იქნას რთული ტესტის სცენარების ავტომატიზაციისთვის მომხმარებლის ურთიერთქმედების სიმულაციის გზით, ტესტის მონაცემებზე დაყრდნობით გადაწყვეტილებების მიღებისა და ტესტის პირობების შეცვლასთან ადაპტაციით.

რა არის LangChain?

LangChain არის ღია კოდის ორკესტრირების ხელსაწყო, რომელიც დეველოპერებს საშუალებას აძლევს შექმნან კომპლექსური AI სისტემები პროგრამირების სხვადასხვა ენების გამოყენებით, მათ შორის Python, Rust და Go. LangChain უზრუნველყოფს მოქნილ და მოდულურ არქიტექტურას, რომელიც დეველოპერებს საშუალებას აძლევს გააერთიანონ სხვადასხვა AI კომპონენტები, როგორიცაა ბუნებრივი ენის დამუშავება (NLP) და კომპიუტერული ხედვა, დახვეწილი AI სისტემების შესაქმნელად.

** რა არის DSPy?**

DSPy არის პითონის ბიბლიოთეკა, რომელიც უზრუნველყოფს ინსტრუმენტების კომპლექტს ხელოვნური ინტელექტის სისტემების შესაქმნელად და განსათავსებლად. DSPy შექმნილია იმისთვის, რომ შეუფერხებლად იმუშაოს LangChain-თან და უზრუნველყოფს უამრავ ფუნქციას, მათ შორის მონაცემთა დამუშავებას, მანქანურ სწავლებას და ღრმა სწავლებას.

აგენტური AI დანერგვა დეტერმინისტული ტესტის ავტომატიზაციაში

აგენტური AI განმსაზღვრელი ტესტის ავტომატიზაციაში განსახორციელებლად, ჩვენ შეგვიძლია გამოვიყენოთ LangChain და DSPy ტესტის ავტომატიზაციის ჩარჩოს შესაქმნელად, რომელიც ახდენს მომხმარებლის ურთიერთქმედების სიმულაციას, იღებს გადაწყვეტილებებს ტესტის მონაცემებზე დაყრდნობით და ადაპტირდება ტესტის პირობების შეცვლასთან.

აქ არის მარტივი მაგალითი იმისა, თუ როგორ შეგვიძლია გამოვიყენოთ LangChain და DSPy ტესტის სცენარის ავტომატიზაციისთვის: ``პითონი იმპორტის ლანგჯაინი langchain.chains-დან იმპორტი LLMChain langchain.llms-დან იმპორტი DSPyLLM

ტესტის_სცენარი = { "user_input": "შესვლა", "expected_output": "შესვლა წარმატებულია" }

განსაზღვრეთ აგენტური AI აგენტი

აგენტი = LLMCchain ( llm=DSpyLLM(), შეყვანის_ტიპი = "ტექსტი", output_type = "ტექსტი" )

განსაზღვრეთ ტესტის ავტომატიზაციის ფუნქცია

def test_automation (ტესტი_სცენარი): # მომხმარებლის ურთიერთქმედების სიმულაცია user_input = test_scenario["user_input"] # მიიღეთ გადაწყვეტილება ტესტის მონაცემების საფუძველზე გადაწყვეტილება = agent.run(user_input) # შეეგუეთ გამოცდის პირობებს თუ გადაწყვეტილება == "შესვლა წარმატებულია": ბეჭდვა ("ტესტი ჩააბარა") სხვა: ბეჭდვა ("ტესტი ვერ მოხერხდა")

გაუშვით ტესტის ავტომატიზაციის ფუნქცია

ტესტი_ავტომატიზაცია (ტესტის_სცენარი)

ამ მაგალითში ჩვენ განვსაზღვრავთ ტესტის სცენარს, რომელიც მოიცავს მომხმარებლის ურთიერთქმედების სიმულაციას, ტესტის მონაცემებზე დაფუძნებული გადაწყვეტილების მიღებას და ტესტის პირობების შეცვლას. შემდეგ ჩვენ განვსაზღვრავთ აგენტური AI აგენტს LangChain-ისა და DSPy-ის გამოყენებით და ვიყენებთ მას ტესტის სცენარის ავტომატიზაციისთვის.

** ტოპ 5-10 ყველაზე ხშირად გამოყენებული ბრძანება/ნაწყვეტი**

აქ არის ტოპ 5-10 ყველაზე ხშირად გამოყენებული ბრძანება/ნაწყვეტი LangChain-ისა და DSPy-სთვის:

1. `langchain.LLMChain(llm=DSPyLLM())`: ქმნის აგენტური AI აგენტს LangChain-ისა და DSPy-ის გამოყენებით.
2. `DSPyLLM()`: ახდენს DSPy LLM (დიდი ენობრივი მოდელი) ინსტანციის ინიცირებას.
3. `LLMChain(input_type="text", output_type="text")`: ქმნის Agentic AI აგენტს ტექსტის შეყვანისა და გამომავალი ტიპებით.
4. `agent.run(user_input)`: აწარმოებს Agentic AI აგენტს მომხმარებლის შეყვანით.
5. `test_scenario = {"user_input": "login", "expected_output": "login წარმატებული"}`: განსაზღვრავს ტესტის სცენარს მომხმარებლის შეყვანით და მოსალოდნელი გამომავალით.
6. `langchain.chains.LLMChain(llm=DSPyLLM())`: ქმნის Agentic AI აგენტს LangChain-ისა და DSPy-ის გამოყენებით.
7. `DSPyLLM().predict(user_input)`: პროგნოზირებს DSPy LLM-ის გამომავალს მომხმარებლის შეყვანით.
8. `LLMChain(input_type="text", output_type="text").run(user_input)`: აწარმოებს Agentic AI აგენტს ტექსტის შეყვანისა და გამომავალი ტიპებით.
9. `test_automation(test_scenario)`: აწარმოებს ტესტის ავტომატიზაციის ფუნქციას ტესტის სცენარით.
10. `langchain.chains.LLMChain(llm=DSPyLLM()).run(user_input)`: აწარმოებს Agentic AI აგენტს მომხმარებლის შეყვანით.

** ვიზუალიზაცია **

აქ არის აგენტური AI აგენტის ვიზუალიზაცია Chart.js-ის გამოყენებით:
``ჯსონ
{
  "ტიპი": "ბარი",
  "მონაცემები": {
    "labels": ["მომხმარებლის შეყვანა", "გადაწყვეტილება", "ადაპტაცია"],
    "მონაცემთა ნაკრები": [
      {
        "label": "Agentic AI Agent",
        "მონაცემები": [10, 20, 30],
        "backgroundColor": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        "საზღვრის სიგანე": 1
      }
    ]
  },
  "ოფციები": {
    "სათაური": {
      "ჩვენება": მართალია,
      "text": "Agent AI Agent"
    },
    "სასწორები": {
      "yAxes": [
        {
          "ტკიპები": {
            "beginAtZero": მართალია
          }
        }
      ]
    }
  }
}

ეს ვიზუალიზაცია აჩვენებს აგენტური AI აგენტის მუშაობას მომხმარებელთა ურთიერთქმედების სიმულაციაში, ტესტის მონაცემებზე დაფუძნებული გადაწყვეტილებების მიღებაში და ტესტის პირობების შეცვლასთან ადაპტაციაში.

დასკვნა

ამ სტატიაში ჩვენ გამოვიკვლიეთ აგენტური AI, ორკესტრირების ხელსაწყოების და პროგრამული უზრუნველყოფის ინჟინერიის კვეთა რთული ტესტის სცენარების ავტომატიზაციისთვის LangChain-ისა და DSPy-ის გამოყენებით. ჩვენ განვახორციელეთ აგენტური ხელოვნური ინტელექტის მარტივი მაგალითი დეტერმინისტული ტესტის ავტომატიზაციაში და მოგვაწოდეთ ბრძანებების/სნიპეტების მთელი რიგი LangChain-ისთვის და DSPy-სთვის. ჩვენ ასევე ვიზუალურად ვაჩვენეთ აგენტური AI აგენტის მუშაობა Chart.js-ის გამოყენებით. Agentic AI და Orchestration Tools-ის გამოყენებით, დეველოპერებს შეუძლიათ შექმნან დახვეწილი ტესტის ავტომატიზაციის ჩარჩოები, რომლებიც ახდენენ მომხმარებლის ურთიერთქმედების სიმულაციას, იღებენ გადაწყვეტილებებს ტესტის მონაცემებზე დაყრდნობით და ადაპტირებენ ტესტის ცვალებად პირობებს.