Գործակալական AI-ի ներդրում դետերմինիստական թեստային ավտոմատացման մեջ LangChain-ի և DSPy-ի հետ

Ներածություն

Ծրագրային համակարգերի աճող բարդությունը թեստային ավտոմատացումը դարձրել է ծրագրային ապահովման մշակման կարևորագույն ասպեկտ: Ավանդական թեստային ավտոմատացման շրջանակները հիմնված են սցենարային մոտեցումների վրա, որոնք կարող են լինել փխրուն և դժվար է պահպանել: Վերջին տարիներին Agentic AI-ի և Orchestration Tools-ի ի հայտ գալը նոր հնարավորություններ է բացել բարդ թեստային սցենարների ավտոմատացման համար: Այս հոդվածում մենք կուսումնասիրենք Agentic AI-ի, Orchestration Tools-ի և Software Engineering-ի խաչմերուկը՝ LangChain-ի և DSPy-ի միջոցով բարդ փորձարկման սցենարների ավտոմատացման համար:

Ի՞նչ է Agentic AI-ն:

Agentic AI-ն վերաբերում է արհեստական ինտելեկտի մի տեսակին, որը նախատեսված է գործողություններ ձեռնարկելու օգտատիրոջ կամ համակարգի անունից: Գործակալական AI համակարգերն ընդունակ են որոշումներ կայացնել, սովորել փորձից և հարմարվել նոր իրավիճակներին: Փորձարկման ավտոմատացման համատեքստում Agentic AI-ն կարող է օգտագործվել բարդ թեստային սցենարների ավտոմատացման համար՝ մոդելավորելով օգտատերերի փոխազդեցությունները, որոշումներ կայացնելով թեստային տվյալների հիման վրա և հարմարվելով փորձարկման պայմաններին:

Ի՞նչ է LangChain-ը:

LangChain-ը բաց կոդով Orchestration Tool է, որը թույլ է տալիս ծրագրավորողներին կառուցել բարդ AI համակարգեր՝ օգտագործելով ծրագրավորման տարբեր լեզուներ, ներառյալ Python, Rust և Go: LangChain-ն ապահովում է ճկուն և մոդուլային ճարտարապետություն, որը ծրագրավորողներին հնարավորություն է տալիս ինտեգրել AI-ի տարբեր բաղադրիչներ, ինչպիսիք են բնական լեզվի մշակումը (NLP) և համակարգչային տեսլականը, կառուցելու բարդ AI համակարգեր:

Ի՞նչ է DSPy-ը:

DSPy-ը Python գրադարան է, որն ապահովում է մի շարք գործիքներ AI համակարգեր ստեղծելու և տեղակայելու համար: DSPy-ը նախագծված է LangChain-ի հետ անխափան աշխատելու համար և ապահովում է մի շարք հնարավորություններ, ներառյալ տվյալների մշակումը, մեքենայական ուսուցումը և խորը ուսուցումը:

Գործակալական AI-ի ներդրում դետերմինիստական թեստային ավտոմատացման մեջ

Agentic AI-ն դետերմինիստական թեստային ավտոմատացման մեջ կիրառելու համար մենք կարող ենք օգտագործել LangChain-ը և DSPy-ը՝ ստեղծելու թեստային ավտոմատացման շրջանակ, որը մոդելավորում է օգտատերերի փոխազդեցությունները, որոշումներ է կայացնում՝ հիմնվելով թեստային տվյալների վրա և հարմարվում փոփոխվող թեստային պայմաններին:

Ահա մի պարզ օրինակ, թե ինչպես կարող ենք օգտագործել LangChain-ը և DSPy-ն՝ փորձարկման սցենարը ավտոմատացնելու համար. «Պիթոն». ներմուծման լանգշղթա langchain.chains-ից ներմուծել LLMCchain langchain.llms ներմուծման DSPyLLM-ից

թեստի_սցենար = { "user_input": "login", "expected_output": "մուտքը հաջող է" }

Սահմանեք Agentic AI գործակալը

գործակալ = LLMCchain ( llm=DSPyLLM(), input_type = "տեքստ", output_type = "տեքստ" )

Սահմանեք թեստային ավտոմատացման գործառույթը

def test_automation (test_scenario): # Մոդելավորել օգտվողի փոխազդեցությունը user_input = test_scenario["user_input"] # Որոշում կայացրեք՝ հիմնվելով թեստի տվյալների վրա որոշում = agent.run (user_input) # Հարմարվել փոփոխվող փորձարկման պայմաններին եթե որոշումը == «մուտքը հաջողված է»: տպել («Թեստն անցել է») ուրիշ: տպել («Թեստը ձախողվեց»)

Գործարկեք փորձարկման ավտոմատացման գործառույթը

test_automation (փորձարկման_սցենար)

Այս օրինակում մենք սահմանում ենք թեստային սցենար, որը ներառում է օգտատիրոջ փոխազդեցության մոդելավորում, թեստի տվյալների հիման վրա որոշում կայացնելը և թեստի փոփոխվող պայմաններին հարմարվելը: Այնուհետև մենք սահմանում ենք Agentic AI գործակալ՝ օգտագործելով LangChain-ը և DSPy-ը և այն օգտագործում ենք փորձարկման սցենարը ավտոմատացնելու համար:

**Թոփ 5-10 ամենաշատ օգտագործվող հրամաններ/հատվածներ**

Ահա 5-10 ամենաշատ օգտագործվող հրամանները/հատվածները LangChain-ի և DSPy-ի համար.

1. «langchain.LLMChain(llm=DSPyLLM())»: Ստեղծում է Agentic AI գործակալ՝ օգտագործելով LangChain և DSPy:
2. «DSPyLLM()»: Նախաձեռնում է DSPy LLM (Large Language Model) օրինակը:
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 գործակալը՝ օգտվողի մուտքագրմամբ:

**Վիզուալիզացիա**

Ահա Agentic AI գործակալի արտացոլումը Chart.js-ի միջոցով.
```ջսոն
{
  «տեսակ»՝ «բար»,
  "տվյալներ": {
    «պիտակներ»: [«Օգտվողի մուտքագրում», «Որոշում», «Ադապտացիա»],
    «տվյալների հավաքածուներ»:
      {
        «պիտակ»: «Գործակալական AI գործակալ»,
        «տվյալներ»: [10, 20, 30],
        "backgroundColor": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        «սահմանի լայնություն»՝ 1
      }
    ]
  },
  «Ընտրանքներ»: {
    «վերնագիր»: {
      «ցուցադրում»՝ ճշմարիտ,
      "text": "Agentic AI Agent"
    },
    «կշեռքներ»: {
      «yAxes»:
        {
          "ticks": {
            «beginAtZero»: ճիշտ է
          }
        }
      ]
    }
  }
}

Այս վիզուալիզացիան ցույց է տալիս Agentic AI գործակալի աշխատանքը օգտատերերի փոխազդեցությունների մոդելավորման, թեստային տվյալների հիման վրա որոշումներ կայացնելու և փորձարկման փոփոխվող պայմաններին հարմարվելու հարցում:

Եզրակացություն

Այս հոդվածում մենք ուսումնասիրեցինք Agentic AI-ի, Orchestration Tools-ի և Software Engineering-ի խաչմերուկը՝ LangChain-ի և DSPy-ի միջոցով բարդ փորձարկման սցենարների ավտոմատացման համար: Մենք իրականացրել ենք Agentic AI-ի պարզ օրինակ դետերմինիստական ​​թեստային ավտոմատացման մեջ և տրամադրել ենք մի շարք հրամաններ/հատվածներ LangChain-ի և DSPy-ի համար: Մենք նաև պատկերացրել ենք Agentic AI գործակալի աշխատանքը՝ օգտագործելով Chart.js: Օգտագործելով Agentic AI-ն և Orchestration Tools-ը, ծրագրավորողները կարող են ստեղծել թեստային ավտոմատացման բարդ շրջանակներ, որոնք մոդելավորում են օգտատերերի փոխազդեցությունները, որոշումներ կայացնում՝ հիմնվելով թեստի տվյալների վրա և հարմարվում փորձարկման փոփոխվող պայմաններին: