សេចក្តីផ្តើម

ការវិវត្តន៍យ៉ាងឆាប់រហ័សនៃ Artificial Intelligence (AI) និង Machine Learning (ML) បាននាំឱ្យមានការអភិវឌ្ឍន៍នៃភ្នាក់ងារ AI ដែលជាប្រភេទ AI ដែលអាចធ្វើសកម្មភាព និងធ្វើការសម្រេចចិត្តដោយខ្លួនឯង។ បច្ចេកវិទ្យានេះមានសក្តានុពលក្នុងការធ្វើបដិវត្តវិធីដែលយើងចូលទៅជិតស្ថាបត្យកម្មកម្មវិធី និងស្វ័យប្រវត្តិកម្ម DevOps ។ នៅក្នុងអត្ថបទនេះ យើងនឹងស្វែងយល់ពីការរួមបញ្ចូលនៃភ្នាក់ងារ AI គំរូភាសាធំ (LLMs) និងឧបករណ៍ orchestration ដូចជា LangChain និង DSPy ដើម្បីធ្វើស្វ័យប្រវត្តិកម្មស្ថាបត្យកម្មកម្មវិធី ហេដ្ឋារចនាសម្ព័ន្ធ និងដំណើរការ DevOps ។

តើ Agentic AI ជាអ្វី?

Agentic AI សំដៅលើប្រភេទ AI ដែលអាចធ្វើសកម្មភាព និងធ្វើការសម្រេចចិត្តដោយខ្លួនឯង។ នេះគឺផ្ទុយទៅនឹងប្រព័ន្ធ AI ប្រពៃណី ដែលជាធម្មតាត្រូវបានរចនាឡើងដើម្បីបំពេញភារកិច្ចជាក់លាក់ និងអនុវត្តតាមច្បាប់ដែលបានកំណត់ទុកជាមុន។ ម្យ៉ាងវិញទៀត ប្រព័ន្ធ AI Agentic ត្រូវបានរចនាឡើងដើម្បីឱ្យមានភាពស្វយ័តជាងមុន និងអាចសម្របខ្លួនបាន ដែលអនុញ្ញាតឱ្យពួកគេរៀនពីបរិយាកាសរបស់ពួកគេ និងធ្វើការសម្រេចចិត្តដោយផ្អែកលើគោលដៅ និងគោលបំណងផ្ទាល់ខ្លួនរបស់ពួកគេ។

តួនាទីរបស់ LLMs នៅក្នុង Agentic AI

គំរូភាសាធំ (LLMs) គឺជាប្រភេទ AI ដែលត្រូវបានបណ្តុះបណ្តាលលើទិន្នន័យអត្ថបទដ៏ច្រើន និងមានសមត្ថភាពបង្កើតភាសាដូចមនុស្ស។ LLMs គឺជាធាតុផ្សំដ៏សំខាន់នៃប្រព័ន្ធ AI ភ្នាក់ងារ ព្រោះវាផ្តល់នូវសមត្ថភាពក្នុងការយល់ និងបង្កើតភាសារបស់មនុស្ស។ នេះអនុញ្ញាតឱ្យប្រព័ន្ធ AI ភ្នាក់ងារទាក់ទងជាមួយមនុស្ស និងប្រព័ន្ធផ្សេងទៀតតាមរបៀបធម្មជាតិ និងវិចារណញាណ។

ឧបករណ៍ Orchestration៖ LangChain និង DSPy

ឧបករណ៍ Orchestration ដូចជា LangChain និង DSPy ត្រូវបានរចនាឡើងដើម្បីគ្រប់គ្រង និងសម្របសម្រួលអន្តរកម្មរវាងប្រព័ន្ធ និងសមាសធាតុផ្សេងៗគ្នា។ ឧបករណ៍ទាំងនេះផ្តល់នូវវិធីដើម្បីកំណត់ និងប្រតិបត្តិលំហូរការងារ ដែលអាចរួមបញ្ចូលការងារដូចជា ដំណើរការទិន្នន័យ ការបណ្តុះបណ្តាលគំរូ និងការដាក់ឱ្យប្រើប្រាស់។

LangChain

LangChain គឺជាឧបករណ៍ orchestration ប្រភពបើកចំហដែលផ្តល់នូវក្របខ័ណ្ឌដែលអាចបត់បែនបាន និងអាចពង្រីកបានសម្រាប់ការកសាង និងគ្រប់គ្រងលំហូរការងារ។ LangChain ត្រូវ​បាន​រចនា​ឡើង​ដើម្បី​ធ្វើ​ការ​ជាមួយ​ជួរ​ដ៏​ធំ​មួយ​នៃ​ប្រព័ន្ធ​និង​សមាសភាគ​រួម​ទាំង LLMs, មូលដ្ឋាន​ទិន្នន័យ, និង APIs ។

DSPy

DSPy គឺជាឧបករណ៍ orchestration ដែលមានមូលដ្ឋានលើ Python ដែលផ្តល់នូវវិធីសាមញ្ញ និងវិចារណញាណដើម្បីកំណត់ និងប្រតិបត្តិលំហូរការងារ។ DSPy ត្រូវ​បាន​រចនា​ឡើង​ដើម្បី​ធ្វើ​ការ​ជាមួយ​ជួរ​ដ៏​ធំ​មួយ​នៃ​ប្រព័ន្ធ និង​សមាសភាគ​រួម​ទាំង LLMs មូលដ្ឋាន​ទិន្នន័យ និង APIs ។

ដំណើរការស្ថាបត្យកម្មកម្មវិធីដោយស្វ័យប្រវត្តិ និងដំណើរការ DevOps

Agentic AI, LLMs និងឧបករណ៍ orchestration ដូចជា LangChain និង DSPy អាចត្រូវបានប្រើដើម្បីធ្វើស្វ័យប្រវត្តិកម្មជាច្រើននៃស្ថាបត្យកម្មកម្មវិធី និងដំណើរការ DevOps ។ ឧទាហរណ៍មួយចំនួនរួមមាន:

• ការពិនិត្យមើលកូដដោយស្វ័យប្រវត្តិ៖ ប្រព័ន្ធ AI Agentic អាចត្រូវបានប្រើដើម្បីពិនិត្យមើលកូដ និងកំណត់បញ្ហាដែលអាចកើតមាន ដូចជាកំហុស និងភាពងាយរងគ្រោះផ្នែកសុវត្ថិភាព។ ** ការធ្វើតេស្តស្វ័យប្រវត្តិ**៖ ប្រព័ន្ធ AI ភ្នាក់ងារអាចប្រើដើម្បីធ្វើការធ្វើតេស្តដោយស្វ័យប្រវត្តិ រួមទាំងការធ្វើតេស្តឯកតា ការធ្វើតេស្តរួមបញ្ចូល និងការធ្វើតេស្តពីចុងដល់ចប់។
• ការដាក់ពង្រាយដោយស្វ័យប្រវត្តិ៖ ប្រព័ន្ធ AI Agentic អាចត្រូវបានប្រើដើម្បីធ្វើឱ្យការដាក់ពង្រាយដោយស្វ័យប្រវត្តិ រួមទាំងការដាក់ឱ្យប្រើប្រាស់កូដ ការកំណត់រចនាសម្ព័ន្ធ និងធនធានផ្សេងទៀត។
• ការត្រួតពិនិត្យដោយស្វ័យប្រវត្តិ៖ ប្រព័ន្ធ AI Agentic អាចត្រូវបានប្រើដើម្បីធ្វើការត្រួតពិនិត្យដោយស្វ័យប្រវត្តិ រួមទាំងការត្រួតពិនិត្យដំណើរការប្រព័ន្ធ សុវត្ថិភាព និងម៉ែត្រផ្សេងទៀត។

ការអនុវត្តជាក់ស្តែង

នៅក្នុងផ្នែកនេះ យើងនឹងផ្តល់នូវឧទាហរណ៍សាមញ្ញមួយអំពីរបៀបប្រើ LangChain និង DSPy ដើម្បីធ្វើស្វ័យប្រវត្តិកម្មស្ថាបត្យកម្មកម្មវិធី និងដំណើរការ DevOps ។

ឧទាហរណ៍៖ ការពិនិត្យមើលកូដដោយស្វ័យប្រវត្តិ

ក្នុងឧទាហរណ៍នេះ យើងនឹងប្រើ LangChain និង DSPy ដើម្បីធ្វើការត្រួតពិនិត្យកូដដោយស្វ័យប្រវត្តិ។ យើងនឹងកំណត់លំហូរការងារដែលរួមមានជំហានដូចខាងក្រោមៈ

1. ការវិភាគកូដ៖ ដំណើរការការងារនឹងប្រើ LLM ដើម្បីវិភាគកូដ និងកំណត់បញ្ហាដែលអាចកើតមាន។
2. ការពិនិត្យកូដ៖ ដំណើរការការងារនឹងប្រើប្រាស់ប្រព័ន្ធ AI ភ្នាក់ងារដើម្បីពិនិត្យមើលកូដ និងកំណត់បញ្ហាដែលអាចកើតមាន។
3. ការដាក់ឱ្យប្រើប្រាស់កូដ៖ ដំណើរការការងារនឹងប្រើឧបករណ៍ដាក់ពង្រាយ ដើម្បីដាក់ពង្រាយកូដទៅកាន់បរិយាកាសផលិតកម្ម។

នេះគឺជាឧទាហរណ៍នៃរបៀបអនុវត្តលំហូរការងារនេះដោយប្រើ LangChain និង DSPy៖ ``ពស់ថ្លាន់ នាំចូល langchain ពី langchain នាំចូល LLM

កំណត់ LLM

llm = LLM("text-davinci-003")

កំណត់ប្រព័ន្ធ AI ភ្នាក់ងារ

ai_system = langchain.AgenticAI()

កំណត់លំហូរការងារ

លំហូរការងារ = langchain.Workflow( ជំហាន=[ langchain.ជំហាន( name="ការវិភាគកូដ", func=llm.analyze_code, inputs={"code": "def hello_world(): print('Hello World')"}, ) langchain.ជំហាន( name="ពិនិត្យកូដ", func=ai_system.review_code, inputs={"code": "def hello_world(): print('Hello World')"}, ) langchain.ជំហាន( name="ការ​ដាក់​ឱ្យ​ប្រើ​កូដ", func=langchain.deploy_code, inputs={"code": "def hello_world(): print('Hello World')"}, ) ] )

អនុវត្តលំហូរការងារ

workflow.execute()

កូដនេះកំណត់លំហូរការងារដែលរួមមានបីជំហាន៖ ការវិភាគកូដ ការពិនិត្យមើលកូដ និងការដាក់ឱ្យប្រើប្រាស់កូដ។ លំហូរការងារប្រើ LLM ដើម្បីវិភាគកូដ ប្រព័ន្ធ AI ភ្នាក់ងារដើម្បីពិនិត្យមើលកូដ និងឧបករណ៍ដាក់ពង្រាយដើម្បីដាក់ពង្រាយកូដទៅកាន់បរិយាកាសផលិតកម្ម។

## កំពូល 5-10 ពាក្យបញ្ជាដែលប្រើច្រើនបំផុត / អត្ថបទខ្លីៗ

នេះគឺជា 5-10 ពាក្យបញ្ជាដែលប្រើច្រើនជាងគេបំផុតសម្រាប់ LangChain និង DSPy៖

1. `langchain.Workflow(steps=[...])`: កំណត់លំហូរការងារដែលមានជំហានច្រើន។
2. `langchain.Step(name="...", func=..., inputs={...})`: កំណត់ជំហានតែមួយនៅក្នុងលំហូរការងារ។
3. `llm.analyze_code(inputs={"code": ...})`: ប្រើ LLM ដើម្បីវិភាគកូដ។
4. `ai_system.review_code(inputs={"code": ...})`៖ ប្រើប្រព័ន្ធ AI ភ្នាក់ងារដើម្បីពិនិត្យមើលកូដ។
5. `langchain.deploy_code(inputs={"code": ... })`: ដាក់ពង្រាយកូដទៅបរិយាកាសផលិតកម្ម។
6. `langchain.AgenticAI()`៖ បង្កើតឧទាហរណ៍នៃប្រព័ន្ធ AI ភ្នាក់ងារ។
7. `langchain.LLM()`: បង្កើតឧទាហរណ៍នៃ LLM ។
8. `langchain.deploy_code()`៖ ប្រើលេខកូដទៅបរិយាកាសផលិតកម្ម។
9. `langchain.execute_workflow()`: ប្រតិបត្តិលំហូរការងារ។
10. `langchain.get_workflow_status()`: ទទួលបានស្ថានភាពនៃលំហូរការងារ។

## ការមើលឃើញ

នេះជាឧទាហរណ៍នៃរបៀបមើលឃើញលំហូរការងារដោយប្រើ Chart.js៖
```json
{
  "type": "របារ",
  "ទិន្នន័យ"៖ {
    "labels": ["ការវិភាគកូដ", "ការពិនិត្យកូដ", "ការដាក់ឱ្យប្រើប្រាស់កូដ"],
    "សំណុំទិន្នន័យ": [
      {
        "label": "ជំហានលំហូរការងារ",
        "ទិន្នន័យ": [10, 20, 30],
        "ពណ៌ផ្ទៃខាងក្រោយ": [
          "rgba(255, 99, 132, 0.2)",
          "rgba(54, 162, 235, 0.2)",
          "rgba(255, 206, 86, 0.2)"
        ],
        "ពណ៌ព្រំដែន": [
          "rgba(255, 99, 132, 1)",
          "rgba(54, 162, 235, 1)",
          "rgba(255, 206, 86, 1)"
        ],
        "ទទឹងព្រំដែន"៖ ១
      }
    ]
  },
  "ជម្រើស"៖ {}
}

កូដនេះកំណត់តារាងរបារដែលមានស្លាកចំនួនបី៖ ការវិភាគកូដ ការត្រួតពិនិត្យកូដ និងការដាក់ឱ្យប្រើប្រាស់កូដ។ តារាងបង្ហាញពីចំនួនជំហានក្នុងដំណាក់កាលនីមួយៗនៃដំណើរការការងារ។

សេចក្តីសន្និដ្ឋាន

Agentic AI, LLMs និងឧបករណ៍ orchestration ដូចជា LangChain និង DSPy មានសក្តានុពលក្នុងការធ្វើបដិវត្តវិធីដែលយើងចូលទៅស្ថាបត្យកម្មកម្មវិធី និងស្វ័យប្រវត្តិកម្ម DevOps ។ តាមរយៈ​ការ​ធ្វើ​កិច្ចការ​ដោយ​ស្វ័យ​ប្រវត្តិ​ដូចជា​ការ​ពិនិត្យ​កូដ ការ​ធ្វើ​តេស្ត និង​ការ​ដាក់​ឱ្យ​ប្រើ យើង​អាច​ធ្វើ​ឱ្យ​ប្រសើរ​ឡើង​នូវ​ប្រសិទ្ធភាព និង​ប្រសិទ្ធភាព​នៃ​ដំណើរការ​អភិវឌ្ឍន៍​របស់​យើង។ នៅក្នុងអត្ថបទនេះ យើងបានស្វែងយល់ពីការរួមបញ្ចូលនៃបច្ចេកវិទ្យាទាំងនេះ ហើយបានផ្តល់នូវឧទាហរណ៍ដ៏សាមញ្ញមួយអំពីរបៀបប្រើពួកវា ដើម្បីធ្វើស្វ័យប្រវត្តិកម្មស្ថាបត្យកម្មកម្មវិធី និងដំណើរការ DevOps ។