ai-agents-for-beginners

របៀបរចនាចរន្តជំនាញ AI Agents ល្អ

(សូមចុចរូបភាពខាងលើដើម្បីមើលវីដេអូរបស់មេរៀននេះ)

លំនាំរចនាការប្រើឧបករណ៍

ឧបករណ៍គឺសំខាន់ ព្រោះវាអនុញ្ញាតឲ្យភ្នាក់ងារជំនាញ AI មានសមត្ថភាពទូលំទូលាយជាងមុន។ ផ្ទុយពីជាក់លាក់ទៅនឹងសកម្មភាពដែលភ្នាក់ងារអាចបំពេញបានត្រឹមតែខ្ពស់មួយទេ ដោយការបន្ថែមឧបករណ៍ អ្នកភ្នាក់ងារអាចបំពេញសកម្មភាពជាច្រើនបាន។ ក្នុងជំពូកនេះ យើងនឹងពិនិត្យលំនាំរចនាការប្រើឧបករណ៍ ដែលពិពណ៌នាថា តើភ្នាក់ងារជំនាញ AI អាចប្រើឧបករណ៍ជាក់លាក់ដើម្បីសម្រេចគោលបំណងរបស់ពួកគេយ៉ាងដូចម្តេច។

ការណែនាំ

ក្នុងមេរៀននេះ យើងបានស្វែងរកចម្លើយសម្រាប់សំណួរខាងក្រោម៖

គោលបំណងការសិក្សា

បន្ទាប់ពីបញ្ចប់មេរៀននេះ អ្នកនឹងអាច:

តើលំនាំរចនាការប្រើឧបករណ៍ជាអ្វី?

លំនាំរចនាការប្រើឧបករណ៍ ផ្តោតលើការបន្តិចបន្តួច LLMs ដើម្បីអាចធ្វើអន្តរកម្មជាមួយឧបករណ៍ខាងក្រៅដើម្បីសម្រេចគោលបំណងជាក់លាក់។ ឧបករណ៍គឺជាកូដដែលភ្នាក់ងារអាចអនុវត្តបានសម្រាប់បំពេញសកម្មភាពមួយ។ ឧបករណ៍អាចជាអនុគមន៍សាមញ្ញដូចជាគណនេយ្យ មួយ ឬជា API ដែលហៅទៅកាន់សេវាកម្មទី៣ ដូចជាការស្វែងរកតម្លៃភាគហ៊ុន ឬការព្យាករណ៍អាកាសធាតុ។ នៅក្នុងបរិបទភ្នាក់ងារជំនាញ AI ឧបករណ៍ត្រូវបានរចនាឡើងដើម្បីអនុវត្តដោយភ្នាក់ងារតាមការហៅអនុគមន៍ដែលបានបង្កើតដោយម៉ូដែល។

តើវាអាចប្រើទៅករណីណាខ្លះ?

ភ្នាក់ងារជំនាញ AI អាចប្រើឧបករណ៍ដើម្បីបញ្ចប់កិច្ចការញឹកញាប់ប៉ុន្មាន ស្វែងរកព័ត៌មាន ឬធ្វើការសម្រេចចិត្ត។ លំនាំរចនាការប្រើឧបករណ៍ច្រើនត្រូវបានប្រើក្នុងស្ថានភាពត្រូវការអន្តរកម្មដើម្បីប្រើប្រាស់ស៊ីសធីមខាងក្រៅ ដូចជា ឃ្លាំងទិន្នន័យ សេវាWeb ឬកូដសំភាសន៍។ សមត្ថភាពនេះមានប្រយោជន៍សម្រាប់ករណីផ្សេងៗគ្នា រួមមាន៖

តើធាតុ/ឋានៈអ្វីខ្លះត្រូវការដើម្បីអនុវត្តលំនាំរចនាការប្រើឧបករណ៍?

ឋានៈទាំងនេះអនុញ្ញាតឲ្យភ្នាក់ងារអាចបំពេញកិច្ចការច្រើន។ មកមើលធាតុសំខាន់ៗក្នុងការអនុវត្តលំនាំរចនាការប្រើឧបករណ៍ៈ

បន្ទាប់មក យើងមកមើលការហៅអនុគមន៍/ឧបករណ៍យ៉ាងละเอียดជាងនេះ។

ការហៅអនុគមន៍/ឧបករណ៍

ការហៅអនុគមន៍ជារបៀបសំខាន់សម្រាប់ផ្តល់សិទ្ធិឲ្យម៉ូឌែលភាសាធំ (LLMs) អាចអន្តរកម្មជាមួយឧបករណ៍។ អ្នកនឹងឃើញពាក្យ ‘អនុគមន៍’ និង ‘ឧបករណ៍’ ត្រូវបានប្រើសំដៅមួយចំនួន ព្រោះ ‘អនុគមន៍’ គឺជាសំណុំកូដដែលអាចប្រើឡើងវិញ ហើយជាឧបករណ៍ដែលភ្នាក់ងារប្រើសម្រាប់បំពេញកិច្ចការ។ ដើម្បីអនុញ្ញាតឲ្យកូដអនុគមន៍ត្រូវបានហៅ LLM ត្រូវតែប្រៀបធៀបសំណើរបស់អ្នកប្រើនឹងពិពណ៌នាអនុគមន៍។ ដើម្បីធ្វើនេះ គួរតែមានស្ពីសម៉ោងដែលផ្ទុកពិពណ៌នាអំពីអនុគមន៍ទាំងអស់ដែលមាន ដាក់ផ្ញើទៅ LLM។ វាហេប្បត្តិការលើកឡើងអនុគមន៍ត្រឹមត្រូវសម្រាប់កិច្ចការ និងត្រឡប់ឈ្មោះជាមួយប៉ារ៉ាម៉ែត្រ។ អនុគមន៍ដែលបានជ្រើសត្រូវបានហៅ ហើយចម្លើយត្រូវបានផ្ញើតបទៅL LLM ដែលប្រើព័ត៌មានដើម្បីឆ្លើយសំណើរអ្នកប្រើ។

សម្រាប់អ្នកអភិវឌ្ឍអាចអនុវត្តការហៅអនុគមន៍សម្រាប់ភ្នាក់ងារ អ្នកត្រូវការប្រភេទខាងក្រោម៖

  1. ម៉ូឌែល LLM ដែលគាំទ្រការហៅអនុគមន៍
  2. ស្ពីសម៉ោង JSON ដែលមានពិពណ៌នាអនុគមន៍
  3. កូដសម្រាប់អនុគមន៍នីមួយៗដែលបានពិពណ៌នា

យើងប្រើឧទាហរណ៍ទទួលពេលវេលាបច្ចុប្បន្ននៅក្នុងទីក្រុងមួយដើម្បីបង្ហាញ៖

  1. ចាប់ផ្តើមម៉ូឌែល LLM ដែលគាំទ្រការហៅអនុគមន៍៖

    ម៉ូឌែលទាំងអស់មិនគាំទ្រការហៅអនុគមន៍ទេ ដូច្នេះវាសំខាន់ក្នុងការត្រួតពិនិត្យថា LLM ដែលអ្នកកំពុងប្រើគាំទ្រមែនឬទេ។ Azure OpenAI គាំទ្រការហៅអនុគមន៍។ យើងអាចចាប់ផ្តើមដោយបង្កើតអតិថិជន OpenAI ប្រកបដោយ API Responses របស់ Azure OpenAI (ចំណុចចូល ដោត /openai/v1/ ដែលមានស្ថិរភាព — មិនចាំបាច់មាន api_version)។

     # ចាប់ផ្ដើមម៉ាស៊ីនអតិថិជន OpenAI សម្រាប់ Azure OpenAI (API ចម្លើយ, ចំណុចចូល v1)
 client = OpenAI(
     base_url=f"{os.environ['AZURE_OPENAI_ENDPOINT'].rstrip('/')}/openai/v1/",
     api_key=os.environ["AZURE_OPENAI_API_KEY"],
 )
 deployment_name = os.environ["AZURE_OPENAI_DEPLOYMENT"]

  2. បង្កើតស្ពីសម៉ោងអនុគមន៍:

    បន្ទាប់មកយើងនឹងកំណត់ស្ពីសម៉ោង JSON ដែលមានឈ្មោះអនុគមន៍ ពីពណ៌នាអំពីអ្វីដែលអនុគមន៍ធ្វើ និងឈ្មោះនិងបរិយាយប៉ារ៉ាម៉ែត្រអនុគមន៍។ បន្ទាប់យើងនឹងផ្ញើស្ពីសម៉ោងនេះទៅអតិថិជនដែលបានបង្កើតជាបញ្ជាក់ ព្រមទាំងសំណើរអ្នកប្រើស្វែងរកពេលវេលានៅសានហ្វ្រងស៊ីស្កូ។ មួយអ្វីសំខាន់គួរឱ្យចំណាំថា ការហៅឧបករណ៍ គឺជាអ្វីដែលត្រូវបានបញ្ជូនត្រឡប់មក មិនមែនឆ្លើយតបចុងក្រោយនៃសំណួរទេ។ ដូចបាននិយាយមុន LLM ឆ្លើយតបឈ្មោះអនុគមន៍ដែលបានជ្រើសសម្រាប់កិច្ចការ និងប៉ារ៉ាម៉ែត្រ ដែលនឹងផ្ញើទៅវា។

     # ការពិពណ៌នាអំពីមុខងារសម្រាប់គំរូក្នុងការអាន (ទ្រង់ទ្រាយឧបករណ៍ផ្ទាំង API ឆ្លើយតប)
 tools = [
     {
         "type": "function",
         "name": "get_current_time",
         "description": "Get the current time in a given location",
         "parameters": {
             "type": "object",
             "properties": {
                 "location": {
                     "type": "string",
                     "description": "The city name, e.g. San Francisco",
                 },
             },
             "required": ["location"],
         },
     }
 ]

      
 # សារមូលដ្ឋានអ្នកប្រើប្រាស់ដំបូង
 messages = [{"role": "user", "content": "What's the current time in San Francisco"}]

 # អំពាវនាវ API ដំបូង: សុំម៉ូឌែលប្រើមុខងារ
 response = client.responses.create(
     model=deployment_name,
     input=messages,
     tools=tools,
     tool_choice="auto",
     store=False,
 )

 # API ពោលតបតបរមានការហៅឧបករណ៍ជារបស់ function_call ក្នុង response.output។
 # បន្ថែមពួកវាទៅកាន់ការសន្ទនាដើម្បីឲ្យម៉ូឌែលមានបរិបទពេញលេញនៅក្នុងជំហានបន្ទាប់។
 messages += response.output

 print("Model's response:")
 print(response.output)
  

     Model's response:
 [ResponseFunctionToolCall(arguments='{"location":"San Francisco"}', call_id='call_pOsKdUlqvdyttYB67MOj434b', name='get_current_time', type='function_call')]

  3. កូដអនុគមន៍ដែលត្រូវការសម្រាប់បំពេញកិច្ចការ:

    ឥឡូវដែល LLM បានជ្រើសអនុគមន៍មួយដែលត្រូវធ្វើ កូដដើម្បីអនុវត្តន៍កិច្ចការត្រូវតែត្រៀមតាំង និងអនុវត្ត។ យើងអាចអនុវត្តកូដដើម្បីទទួលពេលវេលាបច្ចុប្បន្នជាភាសា Python។ អ្នកត្រូវតែសរសេរកូដដើម្បីដកឈ្មោះ និងប៉ារ៉ាម៉ែត្រពី response_message ដើម្បីទទួលបានលទ្ធផលចុងក្រោយ។

       def get_current_time(location):
     """Get the current time for a given location"""
     print(f"get_current_time called with location: {location}")  
     location_lower = location.lower()
        
     for key, timezone in TIMEZONE_DATA.items():
         if key in location_lower:
             print(f"Timezone found for {key}")  
             current_time = datetime.now(ZoneInfo(timezone)).strftime("%I:%M %p")
             return json.dumps({
                 "location": location,
                 "current_time": current_time
             })
      
     print(f"No timezone data found for {location_lower}")  
     return json.dumps({"location": location, "current_time": "unknown"})

     # ដោះស្រាយការហៅមុខងារ
 tool_calls = [item for item in response.output if item.type == "function_call"]
 if tool_calls:
     for tool_call in tool_calls:
         if tool_call.name == "get_current_time":

             function_args = json.loads(tool_call.arguments)

             time_response = get_current_time(
                 location=function_args.get("location")
             )

             # ត្រឡប់លទ្ធផលឧបករណ៍ជារបស់ function_call_output
             messages.append({
                 "type": "function_call_output",
                 "call_id": tool_call.call_id,
                 "output": time_response,
             })
 else:
     print("No tool calls were made by the model.")

 # ការហៅ API លើកទីពីរ៖ ទទួលបានចម្លើយចុងក្រោយពីម៉ូដែល
 final_response = client.responses.create(
     model=deployment_name,
     input=messages,
     tools=tools,
     store=False,
 )

 return final_response.output_text

       get_current_time called with location: San Francisco
   Timezone found for san francisco
   The current time in San Francisco is 09:24 AM.

ការហៅអនុគមន៍គឺជាគន្លងស្នូលនៃការរចនាការប្រើឧបករណ៍ភ្នាក់ងារ សម្រាប់ភាគច្រើន ឬទាំងមូល ប៉ុន្តែការអនុវត្តពីចាប់ផ្តើមអាចមានលំបាក។ ដូចដែលយើងបានរៀននៅ មេរៀនទី 2 រចនាសម្ព័ន្ធភ្នាក់ងារផ្តល់ឱ្យយើងនូវឋានៈដែលបានបង្កើតរួចសម្រាប់អនុវត្តការប្រើឧបករណ៍។

ឧទាហរណ៍ប្រើឧបករណ៍ជាមួយរចនាសម្ព័ន្ធភ្នាក់ងារ

នៅទីនេះមានឧទាហរណ៍មួយចំនួននៃការអនុវត្តលំនាំរចនាការប្រើឧបករណ៍ដោយប្រើរចនាសម្ព័ន្ធភ្នាក់ងារផ្សេងៗគ្នា:

រចនាសម្ព័ន្ធភ្នាក់ងារ Microsoft

រចនាសម្ព័ន្ធភ្នាក់ងារ Microsoft គឺជារចនាសម្ព័ន្ធ AI បើកមូលដ្ឋានសម្រាប់សាងសង់ភ្នាក់ងារជំនាញ AI។ វាធ្វើឲ្យការប្រើការហៅអនុគមន៍មានភាពងាយស្រួលដោយអនុញ្ញាតឲ្យអ្នកកំណត់ឧបករណ៍ជាអនុគមន៍ Python មួយដែលមាន @tool decorator។ រចនាសម្ព័ន្ធនេះគ្រប់គ្រងការអន្តរកម្មទំនាក់ទំនងរវាងម៉ូដែលនិងកូដរបស់អ្នក។ វាក៏ផ្តល់ឧបករណ៍បង្កប់រួចដូចជាការស្វែងរកឯកសារ និងការបកសំឡេងកូដ តាមរយៈ FoundryChatClient។

គំនូរដូចខាងក្រោមបង្ហាញដំណើរការហៅអនុគមន៍ជាមួយរចនាសម្ព័ន្ធភ្នាក់ងារ Microsoft៖

function calling

នៅក្នុងរចនាសម្ព័ន្ធភ្នាក់ងារ Microsoft, ឧបករណ៍ត្រូវបានកំណត់ជាអនុគមន៍ដែលបានតុបតែង។ យើងអាចបម្លែងអនុគមន៍ get_current_time ដែលបានមើលមុនទៅជាឧបករណ៍ដោយប្រើ @tool decorator។ រចនាសម្ព័ន្ធនឹងធ្វើការសម្លៀកបំពាក់អនុគមន៍និងប៉ារ៉ាម៉ែត្ររបស់វាដោយស្វ័យប្រវត្តិ បង្កើតស្ពីសម៉ោងបញ្ចូនទៅ LLM។

import os
from agent_framework import tool
from agent_framework.foundry import FoundryChatClient
from azure.identity import AzureCliCredential

@tool(approval_mode="never_require")
def get_current_time(location: str) -> str:
    """Get the current time for a given location"""
    ...

# បង្កើតអតិថិជន
provider = FoundryChatClient(
    project_endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
    model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
    credential=AzureCliCredential(),
)

# បង្កើតតំណាង និងរត់ជាមួយឧបករណ៍
agent = provider.as_agent(name="TimeAgent", instructions="Use available tools to answer questions.", tools=get_current_time)
response = await agent.run("What time is it?")

សេវាកម្មភ្នាក់ងារ Microsoft Foundry

សេវាកម្មភ្នាក់ងារ Microsoft Foundry គឺជារចនាសម្ព័ន្ធភ្នាក់ងារថ្មី ដែលរចនាឡើងសម្រាប់អភិវឌ្ឍន៍កម្មវិធីដោយមានសុវត្ថិភាព សាងសង់ ចែកចាយ និងពង្រីកភ្នាក់ងារជំនាញ AI ដែលមានគុណភាពខ្ពស់ ដោយមិនចាំបាច់គ្រប់គ្រងធនធានកុំព្យូទ័រ និងកំណត់ត្រាទិន្នន័យ។ វាមានប្រយោជន៍ច្រើនសម្រាប់កម្មវិធីសហគ្រាស ព្រោះវាជាសេវាប្រតិបត្តិការផ្តល់សុវត្ថិភាពកម្រិតខ្ពស់។

បើប្រៀបធៀបជាមួយការអភិវឌ្ឍដោយប្រើ API LLM ថ្នាក់ក្រោម សេវាកម្ម Microsoft Foundry Agent មានអត្ថប្រយោជន៍ខាងក្រោម៖

ឧបករណ៍ដែលមាននៅក្នុងសេវាកម្ម Microsoft Foundry Agent អាចចែកចេញជាសំណុំពីរដែលខ្លះ៖

  1. ឧបករណ៍ចំណេះដឹង៖
  2. ឧបករណ៍សកម្មភាព៖

សេវាកម្មភ្នាក់ងារ អនុញ្ញាតឲ្យយើងប្រើឧបករណ៍ទាំងនេះជាសំណុំឧបករណ៍ toolset។ វាក៏ប្រើ threads ដើម្បីតាមដានប្រវត្តិសារ ពីការសន្ទនា។

សូមស្គាល់ថាអ្នកជាភ្នាក់ងារលក់នៅក្រុមហ៊ុន Contoso។ អ្នកចង់អភិវឌ្ឍភ្នាក់ងារ​សន្ទនា​ដែលអាចឆ្លើយសំណួរអំពីទិន្នន័យលក់របស់អ្នក។

រូបភាពខាងក្រោមបង្ហាញថាអ្នកអាចប្រើសេវាកម្ម Microsoft Foundry Agent ដើម្បីវិភាគទិន្នន័យលក់របស់អ្នក៖

Agentic Service In Action

ដើម្បីប្រើឧបករណ៍ណាមួយជាមួយសេវាកម្មនេះ យើងអាចបង្កើតអតិថិជន ហើយកំណត់ឧបករណ៍ ឬសំណុំឧបករណ៍។ ដើម្បីអនុវត្ត​យ៉ាងជាក់លាក់ អ្នកអាចប្រើកូដ Python ខាងក្រោម។ LLM នឹងមានសិទ្ធិមើលតាម toolset ហើយសម្រេចថាតើប្រើអនុគមន៍ដែលអ្នកប្រើបង្កើត fetch_sales_data_using_sqlite_query ឬកម្មវិធីបកស្រាយកូដដែលមានរួចជាផ្អែកលើសំណើរអ្នកប្រើ។

import os
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from fetch_sales_data_functions import fetch_sales_data_using_sqlite_query # មុខងារ fetch_sales_data_using_sqlite_query ដែលអាចស្វែងរកបាននៅក្នុងឯកសារ fetch_sales_data_functions.py។
from azure.ai.projects.models import ToolSet, FunctionTool, CodeInterpreterTool

project_client = AIProjectClient.from_connection_string(
    credential=DefaultAzureCredential(),
    conn_str=os.environ["PROJECT_CONNECTION_STRING"],
)

# ចាប់ផ្តើមឧបករណ៍
toolset = ToolSet()

# ចាប់ផ្តើមប្រតិភូហៅមុខងារជាមួយមុខងារ fetch_sales_data_using_sqlite_query ហើយបន្ថែមវាទៅឧបករណ៍
fetch_data_function = FunctionTool(fetch_sales_data_using_sqlite_query)
toolset.add(fetch_data_function)

# ចាប់ផ្តើមឧបករណ៍ Interpreter កូដ និងបន្ថែមវាទៅឧបករណ៍។
code_interpreter = CodeInterpreterTool()toolset.add(code_interpreter)

agent = project_client.agents.create_agent(
    model="gpt-5-mini", name="my-agent", instructions="You are helpful agent", 
    toolset=toolset
)

តើមានការពិចារណាពិសេសអ្វីខ្លះសម្រាប់ការប្រើលំនាំរចនាការប្រើឧបករណ៍ដើម្បីសាងសង់ភ្នាក់ងារជំនាញ AI ដែលទទួលបានចិត្តទុកដាក់?

កង្វល់ទូទៅនៃ SQL ដែលបានបង្កើតដោយអូតូម៉ាតិកដោយ LLM គឺសុវត្ថិភាព ជាពិសេសហានិភ័យនៃការចាក់បញ្ចូល SQL ឬសកម្មភាពមិនល្អ ដូចជាការលុបឬបំទុកឃ្លាំងទិន្នន័យ។ ទាំងនេះគឺត្រឹមត្រូវ តែអាចបន្ថយបានយ៉ាងមានប្រសិទ្ធិភាព ដោយផ្ទៀងផ្ទាត់កំណត់សិទ្ធិបើកការចូលទៅឃ្លាំងទិន្នន័យ។ សម្រាប់ឃ្លាំងទិន្នន័យភាគច្រើន វាចាំបាច់ត្រូវកំណត់ឲ្យអានតែតែម្ដង។ សម្រាប់សេវាឃ្លាំងទិន្នន័យដូចជា PostgreSQL ឬ Azure SQL គេគួរឲ្យតែងតំណែងកម្មវិធីជា read-only (SELECT)។

ការរត់កម្មវិធីនៅបរិយាកាសមានសុវត្ថិភាពក៏ជួយពង្រីកការពារជាមួយ។ នៅក្នុងស្ថានភាពសហគ្រាស ទិន្នន័យរងការទាញយក និងបំលែងពីប្រព័ន្ធប្រតិបត្តិការ ទៅឃ្លាំងទិន្នន័យឬឃ្លាំងទិន្នន័យដែលអាចអានបានតែតែម្ដង ដោយមានស្ពីសម៉ោងងាយយល់។ វានៅជួយធានាថាទិន្នន័យមានសុវត្ថិភាព ប្រសិទ្ធភាព និងអាចចូលដំណើរការបាន ទំព័រនិងកម្មវិធីមានសិទ្ធិចូលតិចតួចដើម្បីអានតែតែម្ដង។

កូដគំរូ

តើមានសំណួរច្រើនទៀតអំពីលំនាំរចនាការប្រើឧបករណ៍ទេ?

ចូលរួម Microsoft Foundry Discord ដើម្បីជួបជាមួយអ្នករៀនផ្សេងទៀត ចូលរួមម៉ោងការិយាល័យ និងទទួលបានចម្លើយសំណួរអំពី AI Agents របស់អ្នក។

ឯកសារបន្ថែម

ការពិសោធន៍រថយន្តភ្នាម Agent នេះ (ជាជម្រើស)

បន្ទាប់ពីអ្នករៀនដាក់ប្រោស agent ក្នុង មេរៀនទី 16 អ្នកអាចធ្វើតេស្តរថយន្តភ្នាម TravelToolAgent នៃមេរៀននេះ (តើវាយកឧបករណ៍របស់វាមកហើយឆ្លើយតបរឺ?) ជាមួយ tests/lesson-04-smoke-tests.json។ មើល tests/README.md សម្រាប់របៀបដំណើរការ។

មេរៀនមុននេះ

ការយល់ដឹងអំពីលំនាំរចនាប័ទ្ម Agentic

មេរៀនបន្ទាប់

Agentic RAG

ការបដិសេធ: ឯកសារនេះត្រូវបានបម្លែងភាសា ដោយប្រើសេវាបម្លែងភាសា AI Co-op Translator។ ទោះយើងខ្ញុំមានក្តីប្រាថ្នាឱ្យបានច្បាស់លាស់ តែសូមយល់ដឹងថាការបម្លែងដោយស្វ័យប្រវត្តិក៏អាចមានកំហុសឬភាពមិនត្រឹមត្រូវ។ ឯកសារដើមជាភាសាទីតាំងគួរត្រូវបានគេប្រើជាប្រភពច្បាស់លាស់។ សម្រាប់ព័ត៌មានសំខាន់ៗ សូមណែនាំឱ្យប្រើប្រាស់ការប្រែដោយមនុស្សជំនាញ។ យើងខ្ញុំមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកស្រាយខុសបន្ទាប់ពីការប្រើប្រាស់ការបម្លែងនេះនោះទេ។

This site is open source. Improve this page.