LangChain અને DSPy સાથે ડિટરમિનિસ્ટિક ટેસ્ટ ઓટોમેશનમાં એજન્ટિક AIનો અમલ કરવો

પરિચય

સોફ્ટવેર સિસ્ટમ્સની વધતી જતી જટિલતાએ ટેસ્ટ ઓટોમેશનને સોફ્ટવેર ડેવલપમેન્ટનું નિર્ણાયક પાસું બનાવ્યું છે. પરંપરાગત પરીક્ષણ ઓટોમેશન ફ્રેમવર્ક સ્ક્રિપ્ટેડ અભિગમો પર આધાર રાખે છે, જે બરડ અને જાળવવા મુશ્કેલ હોઈ શકે છે. તાજેતરના વર્ષોમાં, એજન્ટિક AI અને ઓર્કેસ્ટ્રેશન ટૂલ્સના ઉદભવે જટિલ પરીક્ષણ દૃશ્યોને સ્વચાલિત કરવા માટે નવી શક્યતાઓ ખોલી છે. આ લેખમાં, અમે LangChain અને DSPy નો ઉપયોગ કરીને જટિલ પરીક્ષણ દૃશ્યોને સ્વચાલિત કરવા માટે Agentic AI, Orchestration Tools અને Software Engineering ના આંતરછેદનું અન્વેષણ કરીશું.

એજેન્ટિક AI શું છે?

Agentic AI એ કૃત્રિમ બુદ્ધિના પ્રકારનો ઉલ્લેખ કરે છે જે વપરાશકર્તા અથવા સિસ્ટમ વતી પગલાં લેવા માટે રચાયેલ છે. Agentic AI સિસ્ટમ નિર્ણયો લેવા, અનુભવમાંથી શીખવા અને નવી પરિસ્થિતિઓમાં અનુકૂલન કરવામાં સક્ષમ છે. પરીક્ષણ ઓટોમેશનના સંદર્ભમાં, Agentic AI નો ઉપયોગ વપરાશકર્તાની ક્રિયાપ્રતિક્રિયાઓનું અનુકરણ કરીને, પરીક્ષણ ડેટાના આધારે નિર્ણયો લેવા અને પરિક્ષણની બદલાતી પરિસ્થિતિઓને અનુકૂલન કરીને જટિલ પરીક્ષણ દૃશ્યોને સ્વચાલિત કરવા માટે કરી શકાય છે.

લેંગચેન શું છે?

લેંગચેન એ ઓપન સોર્સ ઓર્કેસ્ટ્રેશન ટૂલ છે જે વિકાસકર્તાઓને પાયથોન, રસ્ટ અને ગો સહિતની વિવિધ પ્રોગ્રામિંગ ભાષાઓનો ઉપયોગ કરીને જટિલ AI સિસ્ટમ્સ બનાવવાની મંજૂરી આપે છે. LangChain એક લવચીક અને મોડ્યુલર આર્કિટેક્ચર પ્રદાન કરે છે જે વિકાસકર્તાઓને અત્યાધુનિક AI સિસ્ટમ્સ બનાવવા માટે નેચરલ લેંગ્વેજ પ્રોસેસિંગ (NLP) અને કમ્પ્યુટર વિઝન જેવા વિવિધ AI ઘટકોને એકીકૃત કરવામાં સક્ષમ બનાવે છે.

DSPy શું છે?

DSPy એ પાયથોન લાઇબ્રેરી છે જે AI સિસ્ટમના નિર્માણ અને જમાવટ માટે સાધનોનો સમૂહ પૂરો પાડે છે. DSPy એ LangChain સાથે એકીકૃત રીતે કામ કરવા માટે રચાયેલ છે અને ડેટા પ્રોસેસિંગ, મશીન લર્નિંગ અને ડીપ લર્નિંગ સહિતની વિવિધ સુવિધાઓ પ્રદાન કરે છે.

ડિટરમિનિસ્ટિક ટેસ્ટ ઓટોમેશનમાં એજન્ટિક એઆઈનો અમલ કરવો

નિર્ધારિત પરીક્ષણ ઓટોમેશનમાં Agentic AI ને અમલમાં મૂકવા માટે, અમે લેંગચેન અને DSPy નો ઉપયોગ ટેસ્ટ ઓટોમેશન ફ્રેમવર્ક બનાવવા માટે કરી શકીએ છીએ જે વપરાશકર્તાની ક્રિયાપ્રતિક્રિયાઓનું અનુકરણ કરે છે, પરીક્ષણ ડેટાના આધારે નિર્ણયો લે છે અને પરીક્ષણની બદલાતી પરિસ્થિતિઓને સ્વીકારે છે.

પરીક્ષણ દૃશ્યને સ્વચાલિત કરવા માટે આપણે LangChain અને DSPy નો ઉપયોગ કેવી રીતે કરી શકીએ તેનું એક સરળ ઉદાહરણ અહીં છે: ``અજગર લેંગચેન આયાત કરો langchain.chains માંથી LLMCchain આયાત કરો langchain.llms માંથી DSPyLLM આયાત કરો

પરીક્ષણ_દૃશ્ય = { "user_input": "લોગિન", "expected_output": "લોગિન સફળ" }

Agentic AI એજન્ટને વ્યાખ્યાયિત કરો

એજન્ટ = LLMCchain( llm=DSPyLLM(), input_type="ટેક્સ્ટ", આઉટપુટ_ટાઇપ = ટેક્સ્ટ" )

પરીક્ષણ ઓટોમેશન કાર્ય વ્યાખ્યાયિત કરો

def test_automation(test_senario): # વપરાશકર્તાની ક્રિયાપ્રતિક્રિયાનું અનુકરણ કરો user_input = test_senario["user_input"] # પરીક્ષણ ડેટાના આધારે નિર્ણય લો નિર્ણય = agent.run(user_input) # પરિક્ષણની બદલાતી પરિસ્થિતિઓને અનુકૂલન કરો જો નિર્ણય == "લોગિન સફળ": પ્રિન્ટ ("પરીક્ષા પાસ") બીજું: પ્રિન્ટ ("પરીક્ષણ નિષ્ફળ")

ટેસ્ટ ઓટોમેશન ફંક્શન ચલાવો

પરીક્ષણ_ઓટોમેશન(પરીક્ષણ_દૃશ્ય)

આ ઉદાહરણમાં, અમે એક પરીક્ષણ દૃશ્ય વ્યાખ્યાયિત કરીએ છીએ જેમાં વપરાશકર્તાની ક્રિયાપ્રતિક્રિયાનું અનુકરણ કરવું, પરીક્ષણ ડેટાના આધારે નિર્ણય લેવાનો અને પરીક્ષણની બદલાતી પરિસ્થિતિઓને અનુકૂલન કરવાનો સમાવેશ થાય છે. અમે પછી LangChain અને DSPy નો ઉપયોગ કરીને Agentic AI એજન્ટને વ્યાખ્યાયિત કરીએ છીએ, અને પરીક્ષણ દૃશ્યને સ્વચાલિત કરવા માટે તેનો ઉપયોગ કરીએ છીએ.

**ટોચના 5-10 સૌથી વધુ ઉપયોગમાં લેવાતા આદેશો/સ્નિપેટ્સ**

LangChain અને DSPy માટે અહીં ટોચના 5-10 સૌથી વધુ ઉપયોગમાં લેવાતા આદેશો/સ્નિપેટ્સ છે:

1. `langchain.LLMCchain(llm=DSPyLLM())`: LangChain અને DSPy નો ઉપયોગ કરીને એજન્ટિક AI એજન્ટ બનાવે છે.
2. `DSPyLLM()`: DSPy LLM (લાર્જ લેંગ્વેજ મોડલ) ઇન્સ્ટન્સનો પ્રારંભ કરે છે.
3. `LLMChain(input_type="text", output_type="text")`: ટેક્સ્ટ ઇનપુટ અને આઉટપુટ પ્રકારો સાથે એજન્ટિક 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. `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 એજન્ટ ચલાવે છે.

**વિઝ્યુલાઇઝેશન**

Chart.js નો ઉપયોગ કરીને Agentic AI એજન્ટનું વિઝ્યુલાઇઝેશન અહીં છે:
``જેસન
{
  "પ્રકાર": "બાર",
  "ડેટા": {
    "લેબલ્સ": ["વપરાશકર્તા ઇનપુટ", "નિર્ણય", "અનુકૂલન"],
    "ડેટાસેટ્સ": [
      {
        "label": "એજન્ટિક AI એજન્ટ",
        "ડેટા": [10, 20, 30],
        "બેકગ્રાઉન્ડ કલર": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        "બોર્ડરવિડ્થ": 1
      }
    ]
  },
  "વિકલ્પો": {
    "શીર્ષક": {
      "ડિસ્પ્લે": સાચું,
      "ટેક્સ્ટ": "એજન્ટિક AI એજન્ટ"
    },
    "સ્કેલ્સ": {
      "yAxes": [
        {
          "ટિક્સ": {
            "beginAtZero": સાચું
          }
        }
      ]
    }
  }
}

આ વિઝ્યુલાઇઝેશન એજેન્ટિક AI એજન્ટનું વપરાશકર્તાની ક્રિયાપ્રતિક્રિયાઓનું અનુકરણ કરવા, પરીક્ષણ ડેટાના આધારે નિર્ણયો લેવા અને પરિક્ષણની બદલાતી પરિસ્થિતિઓને અનુરૂપ થવામાં પ્રદર્શન દર્શાવે છે.

નિષ્કર્ષ

આ લેખમાં, અમે LangChain અને DSPy નો ઉપયોગ કરીને જટિલ પરીક્ષણ દૃશ્યોને સ્વચાલિત કરવા માટે Agentic AI, Orchestration Tools અને Software Engineering ના આંતરછેદનું અન્વેષણ કર્યું. અમે નિર્ધારિત પરીક્ષણ ઓટોમેશનમાં Agentic AI નું એક સરળ ઉદાહરણ અમલમાં મૂક્યું છે અને LangChain અને DSPy માટે આદેશો/સ્નિપેટ્સની શ્રેણી પ્રદાન કરી છે. અમે Chart.js નો ઉપયોગ કરીને Agentic AI એજન્ટની કામગીરીની પણ કલ્પના કરી. એજન્ટિક AI અને ઓર્કેસ્ટ્રેશન ટૂલ્સનો લાભ લઈને, વિકાસકર્તાઓ અત્યાધુનિક પરીક્ષણ ઓટોમેશન ફ્રેમવર્ક બનાવી શકે છે જે વપરાશકર્તાની ક્રિયાપ્રતિક્રિયાઓનું અનુકરણ કરે છે, પરીક્ષણ ડેટાના આધારે નિર્ણયો લે છે અને પરીક્ષણની બદલાતી પરિસ્થિતિઓને અનુકૂલન કરે છે.