ai-agents-for-beginners

How to Design Good AI Agents

(മുകളിൽ കാണുന്ന ചിത്രം ക്ലിക്ക് ചെയ്ത് ഈ പാഠത്തിന്റെ വീഡിയോ കാണുക)

ടൂൾ ഉപയോഗ ഡിസൈൻ പാറ്റേൺ

ടൂളുകൾ ആകർഷകമാണ്, കാരണം ഇവ AI ഏജന്റുകൾക്ക് കൂടുതൽ ശേഷികൾ നൽകുന്നു. ഏജന്റിന് നിർവഹിക്കാൻ കഴിയുന്ന പ്രവർത്തനങ്ങളുടെ പരിമിതമായ ഒരു സെറ്റ് മാത്രമുണ്ടായിരുന്നെങ്കിൽ, ഒരു ടൂൾ ചേർത്താൽ, ഏജന്റിന് ഇപ്പോൾ വ്യാപകമായ പ്രവർത്തനങ്ങൾ നിർവഹിക്കാൻ കഴിയും. ഈ അധ്യായത്തിൽ, AI ഏജന്റുകൾ അവരുടെ ലക്ഷ്യങ്ങൾ നേടാൻ പ്രത്യേക ടൂളുകൾ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് വിവരിക്കുന്ന ടൂൾ ഉപയോഗ ഡിസൈൻ പാറ്റേൺ പരിശോധിക്കാം.

പരിചയം

ഈ പാഠത്തിൽ, താഴെ പറയുന്ന ചോദ്യങ്ങൾക്ക് ഉത്തരം കണ്ടെത്തുകയാണ് ലക്ഷ്യം:

പഠന ലക്ഷ്യങ്ങൾ

ഈ പാഠം പൂർത്തിയാക്കിയ ശേഷം, നിങ്ങൾക്ക് കഴിയും:

ടൂൾ ഉപയോഗ ഡിസൈൻ പാറ്റേൺ എന്താണ്?

ടൂൾ ഉപയോഗ ഡിസൈൻ പാറ്റേൺ LLMs-ന് പ്രത്യേക ലക്ഷ്യങ്ങൾ നേടാൻ ബാഹ്യ ടൂളുകളുമായി ഇടപഴകാനുള്ള കഴിവ് നൽകുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു. ടൂളുകൾ ഏജന്റിന് പ്രവർത്തനങ്ങൾ നിർവഹിക്കാൻ കഴിയുന്ന കോഡാണ്. ഒരു ടൂൾ കാൽക്കുലേറ്റർ പോലുള്ള ലളിതമായ ഒരു ഫംഗ്ഷനോ, സ്റ്റോക്ക് വില പരിശോധിക്കലോ കാലാവസ്ഥ പ്രവചനമോ പോലുള്ള മൂന്നാം കക്ഷി സേവനത്തിന് API കോൾ ചെയ്യലോ ആകാം. AI ഏജന്റുകളുടെ സാഹചര്യത്തിൽ, മോഡൽ-ജനിത ഫംഗ്ഷൻ കോൾ-കളുടെ പ്രതികരണമായി ടൂളുകൾ ഏജന്റുകൾക്ക് നിർവഹിക്കാൻ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നു.

ഇത് പ്രയോഗിക്കാവുന്ന ഉപയോഗ കേസുകൾ എന്തൊക്കെയാണ്?

AI ഏജന്റുകൾ സങ്കീർണ്ണമായ പ്രവർത്തനങ്ങൾ പൂർത്തിയാക്കാൻ, വിവരങ്ങൾ തിരികെ നേടാൻ, അല്ലെങ്കിൽ തീരുമാനങ്ങൾ എടുക്കാൻ ടൂളുകൾ ഉപയോഗിക്കാം. ടൂൾ ഉപയോഗ ഡിസൈൻ പാറ്റേൺ ഡൈനാമിക് ആയി ബാഹ്യ സിസ്റ്റങ്ങളുമായി ഇടപഴകേണ്ട സാഹചര്യങ്ങളിൽ സാധാരണയായി ഉപയോഗിക്കുന്നു, ഉദാഹരണത്തിന് ഡാറ്റാബേസുകൾ, വെബ് സേവനങ്ങൾ, അല്ലെങ്കിൽ കോഡ് ഇൻറർപ്രീറ്ററുകൾ. ഈ കഴിവ് വിവിധ ഉപയോഗ കേസുകൾക്കായി പ്രയോജനകരമാണ്, അതിൽ ചിലത്:

ടൂൾ ഉപയോഗ ഡിസൈൻ പാറ്റേൺ നടപ്പിലാക്കാൻ ആവശ്യമായ ഘടകങ്ങൾ/നിർമ്മാണ ഘടനകൾ എന്തൊക്കെയാണ്?

ഈ ഘടകങ്ങൾ AI ഏജന്റിന് വ്യാപകമായ പ്രവർത്തനങ്ങൾ നിർവഹിക്കാൻ സഹായിക്കുന്നു. ടൂൾ ഉപയോഗ ഡിസൈൻ പാറ്റേൺ നടപ്പിലാക്കാൻ ആവശ്യമായ പ്രധാന ഘടകങ്ങൾ നോക്കാം:

അടുത്തതായി, ഫംഗ്ഷൻ/ടൂൾ കോളിംഗ് വിശദമായി നോക്കാം.

ഫംഗ്ഷൻ/ടൂൾ കോളിംഗ്

ഫംഗ്ഷൻ കോളിംഗ് LLMs-ന് ടൂളുകളുമായി ഇടപഴകാൻ പ്രാഥമിക മാർഗമാണ്. ‘ഫംഗ്ഷൻ’ ‘ടൂൾ’ എന്നത് പരസ്പരം ഉപയോഗിക്കുന്നതും കാണാം, കാരണം ‘ഫംഗ്ഷനുകൾ’ (പുനരുപയോഗിക്കാവുന്ന കോഡിന്റെ ബ്ലോക്കുകൾ) ഏജന്റുകൾ പ്രവർത്തനങ്ങൾ നിർവഹിക്കാൻ ഉപയോഗിക്കുന്ന ‘ടൂളുകൾ’ ആണ്. ഒരു ഫംഗ്ഷന്റെ കോഡ് പ്രവർത്തിപ്പിക്കപ്പെടാൻ, LLM ഉപയോക്താവിന്റെ അഭ്യർത്ഥനയെ ഫംഗ്ഷന്റെ വിവരണത്തോട് താരതമ്യം ചെയ്യണം. ലഭ്യമായ എല്ലാ ഫംഗ്ഷനുകളുടെ വിവരണങ്ങൾ അടങ്ങിയ ഒരു സ്കീമ LLM-ന് അയയ്ക്കുന്നു. LLM പിന്നീട് ടാസ്കിനായി ഏറ്റവും അനുയോജ്യമായ ഫംഗ്ഷൻ തിരഞ്ഞെടുക്കുകയും അതിന്റെ പേര്, പാരാമീറ്ററുകൾ തിരികെ നൽകുകയും ചെയ്യുന്നു. തിരഞ്ഞെടുക്കപ്പെട്ട ഫംഗ്ഷൻ പ്രവർത്തിപ്പിക്കപ്പെടുകയും, അതിന്റെ പ്രതികരണം LLM-ന് അയയ്ക്കുകയും, ഉപയോക്താവിന്റെ അഭ്യർത്ഥനയ്ക്ക് പ്രതികരിക്കാൻ LLM ഈ വിവരങ്ങൾ ഉപയോഗിക്കുകയും ചെയ്യുന്നു.

ഏജന്റുകൾക്കായി ഫംഗ്ഷൻ കോളിംഗ് നടപ്പിലാക്കാൻ ഡെവലപ്പർമാർക്ക് ആവശ്യമുള്ളത്:

  1. ഫംഗ്ഷൻ കോളിംഗ് പിന്തുണയ്ക്കുന്ന LLM മോഡൽ
  2. ഫംഗ്ഷൻ വിവരണങ്ങൾ അടങ്ങിയ ഒരു സ്കീമ
  3. വിവരണപ്പെടുത്തിയ ഓരോ ഫംഗ്ഷന്റെയും കോഡ്

സാന്റ്രാൻസിസ്കോയിലെ നിലവിലെ സമയം കണ്ടെത്താനുള്ള ഉദാഹരണം ഉപയോഗിച്ച് വിശദീകരിക്കാം:

  1. ഫംഗ്ഷൻ കോളിംഗ് പിന്തുണയ്ക്കുന്ന LLM ആരംഭിക്കുക:

    എല്ലാ മോഡലുകളും ഫംഗ്ഷൻ കോളിംഗ് പിന്തുണയ്ക്കുന്നില്ല, അതിനാൽ നിങ്ങൾ ഉപയോഗിക്കുന്ന LLM പിന്തുണയ്ക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക. Azure OpenAI ഫംഗ്ഷൻ കോളിംഗ് പിന്തുണയ്ക്കുന്നു. Azure OpenAI ക്ലയന്റ് ആരംഭിച്ച് തുടങ്ങാം.

     # ആസൂർ ഓപ്പൺഎഐ ക്ലയന്റ് ആരംഭിക്കുക
 client = AzureOpenAI(
     azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
     api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
     api_version="2024-05-01-preview"
 )

  2. ഫംഗ്ഷൻ സ്കീമ സൃഷ്ടിക്കുക:

    അടുത്തതായി, ഫംഗ്ഷൻ പേര്, ഫംഗ്ഷൻ എന്താണ് ചെയ്യുന്നത് എന്ന വിവരണം, ഫംഗ്ഷൻ പാരാമീറ്ററുകളുടെ പേരുകളും വിവരണങ്ങളും അടങ്ങിയ JSON സ്കീമ നിർവചിക്കാം. ഈ സ്കീമ ഉപയോക്താവിന്റെ അഭ്യർത്ഥനയോടൊപ്പം മുമ്പ് സൃഷ്ടിച്ച ക്ലയന്റിലേക്ക് അയയ്ക്കാം. ശ്രദ്ധിക്കേണ്ടത്, ടൂൾ കോൾ ആണ് തിരികെ ലഭിക്കുന്നത്, അന്തിമ ഉത്തരമല്ല. മുമ്പ് പറഞ്ഞതുപോലെ, LLM ടാസ്കിനായി തിരഞ്ഞെടുക്കുന്ന ഫംഗ്ഷന്റെ പേര്, പാരാമീറ്ററുകൾ എന്നിവ തിരികെ നൽകുന്നു.

     # മോഡൽ വായിക്കാൻ ഫംഗ്ഷൻ വിവരണം
 tools = [
     {
         "type": "function",
         "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.chat.completions.create(
       model=deployment_name,
       messages=messages,
       tools=tools,
       tool_choice="auto",
   )
  
   # മോഡലിന്റെ പ്രതികരണം പ്രോസസ്സ് ചെയ്യുക
   response_message = response.choices[0].message
   messages.append(response_message)
  
   print("Model's response:")  

   print(response_message)
  

     Model's response:
 ChatCompletionMessage(content=None, role='assistant', function_call=None, tool_calls=[ChatCompletionMessageToolCall(id='call_pOsKdUlqvdyttYB67MOj434b', function=Function(arguments='{"location":"San Francisco"}', name='get_current_time'), type='function')])

  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"})

      # ഫംഗ്ഷൻ കോളുകൾ കൈകാര്യം ചെയ്യുക
   if response_message.tool_calls:
       for tool_call in response_message.tool_calls:
           if tool_call.function.name == "get_current_time":
     
               function_args = json.loads(tool_call.function.arguments)
     
               time_response = get_current_time(
                   location=function_args.get("location")
               )
     
               messages.append({
                   "tool_call_id": tool_call.id,
                   "role": "tool",
                   "name": "get_current_time",
                   "content": time_response,
               })
   else:
       print("No tool calls were made by the model.")  
  
   # രണ്ടാം API കോളുകൾ: മോഡലിൽ നിന്ന് അന്തിമ പ്രതികരണം നേടുക
   final_response = client.chat.completions.create(
       model=deployment_name,
       messages=messages,
   )
  
   return final_response.choices[0].message.content

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

ഫംഗ്ഷൻ കോളിംഗ് ഏജന്റിന്റെ ടൂൾ ഉപയോഗ ഡിസൈൻ പാറ്റേണിന്റെ ഹൃദയമാണ്, എന്നാൽ ഇത് തുടക്കത്തിൽ നിന്ന് നടപ്പിലാക്കുന്നത് ചിലപ്പോൾ വെല്ലുവിളിയാകാം. Lesson 2 ൽ പഠിച്ചതുപോലെ, ഏജന്റിക് ഫ്രെയിംവർക്കുകൾ ടൂൾ ഉപയോഗം നടപ്പിലാക്കാൻ മുൻകൂട്ടി നിർമ്മിച്ച ഘടകങ്ങൾ നൽകുന്നു.

ഏജന്റിക് ഫ്രെയിംവർക്കുകൾ ഉപയോഗിച്ച് ടൂൾ ഉപയോഗ ഉദാഹരണങ്ങൾ

വിവിധ ഏജന്റിക് ഫ്രെയിംവർക്കുകൾ ഉപയോഗിച്ച് ടൂൾ ഉപയോഗ ഡിസൈൻ പാറ്റേൺ എങ്ങനെ നടപ്പിലാക്കാമെന്ന് കാണാം:

സെമാന്റിക് കർണൽ

സെമാന്റിക് കർണൽ .NET, Python, Java ഡെവലപ്പർമാർക്ക് LLMs ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ സഹായിക്കുന്ന ഒരു ഓപ്പൺ-സോഴ്‌സ് AI ഫ്രെയിംവർക്കാണ്. ഫംഗ്ഷൻ കോളിംഗ് ഉപയോഗം ലളിതമാക്കാൻ ഇത് ഫംഗ്ഷനുകളും അവയുടെ പാരാമീറ്ററുകളും മോഡലിലേക്ക് സ്വയം വിവരണം നൽകുന്നു (serializing എന്ന പ്രക്രിയയിലൂടെ). മോഡലും നിങ്ങളുടെ കോഡും തമ്മിലുള്ള ഇടപഴകൽ കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്നു. സെമാന്റിക് കർണൽ പോലുള്ള ഏജന്റിക് ഫ്രെയിംവർക്കുകൾ ഉപയോഗിക്കുന്നതിന്റെ മറ്റൊരു ഗുണം, File Search, Code Interpreter പോലുള്ള മുൻകൂട്ടി നിർമ്മിച്ച ടൂളുകൾ ആക്സസ് ചെയ്യാൻ അനുവദിക്കുന്നു.

താഴെ കാണുന്ന ഡയാഗ്രാം സെമാന്റിക് കർണൽ ഉപയോഗിച്ച് ഫംഗ്ഷൻ കോളിംഗ് പ്രക്രിയയെ ചിത്രീകരിക്കുന്നു:

function calling

സെമാന്റിക് കർണലിൽ ഫംഗ്ഷനുകൾ/ടൂളുകൾ Plugins എന്ന് വിളിക്കുന്നു. മുമ്പ് കണ്ട get_current_time ഫംഗ്ഷനെ ക്ലാസ്സായി മാറ്റി, അതിൽ ഫംഗ്ഷൻ ഉൾപ്പെടുത്തി പ്ലഗിനായി മാറ്റാം. kernel_function ഡെക്കറേറ്റർ ഇറക്കുമതി ചെയ്യാം, ഇത് ഫംഗ്ഷന്റെ വിവരണം സ്വീകരിക്കുന്നു. GetCurrentTimePlugin ഉപയോഗിച്ച് ഒരു കർണൽ സൃഷ്ടിക്കുമ്പോൾ, കർണൽ ഫംഗ്ഷനും അതിന്റെ പാരാമീറ്ററുകളും സ്വയം വിവരണം നൽകുകയും, LLM-ന് അയയ്ക്കാൻ സ്കീമ സൃഷ്ടിക്കുകയും ചെയ്യുന്നു.

from semantic_kernel.functions import kernel_function

class GetCurrentTimePlugin:
    async def __init__(self, location):
        self.location = location

    @kernel_function(
        description="Get the current time for a given location"
    )
    def get_current_time(location: str = ""):
        ...


from semantic_kernel import Kernel

# കർണൽ സൃഷ്ടിക്കുക
kernel = Kernel()

# പ്ലഗിൻ സൃഷ്ടിക്കുക
get_current_time_plugin = GetCurrentTimePlugin(location)

# പ്ലഗിൻ കർണലിൽ ചേർക്കുക
kernel.add_plugin(get_current_time_plugin)

Azure AI Agent Service

Azure AI Agent Service ഡെവലപ്പർമാർക്ക് ഉയർന്ന നിലവാരമുള്ള, വിപുലമായ AI ഏജന്റുകൾ സുരക്ഷിതമായി നിർമ്മിക്കാൻ, വിന്യസിക്കാൻ, സ്കെയിൽ ചെയ്യാൻ സഹായിക്കുന്ന പുതിയ ഏജന്റിക് ഫ്രെയിംവർക്കാണ്. അടിസ്ഥാന കംപ്യൂട്ട്, സ്റ്റോറേജ് റിസോഴ്സുകൾ കൈകാര്യം ചെയ്യേണ്ടതില്ലാതെ ഇത് പ്രവർത്തനക്ഷമമാക്കുന്നു. എന്റർപ്രൈസ് ആപ്ലിക്കേഷനുകൾക്കായി ഇത് പ്രത്യേകമായി പ്രയോജനകരമാണ്, കാരണം ഇത് എന്റർപ്രൈസ് ഗ്രേഡ് സുരക്ഷയുള്ള ഒരു പൂർണ്ണമായ മാനേജ്ഡ് സേവനമാണ്.

LLM API നേരിട്ട് ഉപയോഗിക്കുന്നതുമായി താരതമ്യം ചെയ്യുമ്പോൾ, Azure AI Agent Service ചില ഗുണങ്ങൾ നൽകുന്നു, അതിൽ:

Azure AI Agent Service-ൽ ലഭ്യമായ ടൂളുകൾ രണ്ട് വിഭാഗങ്ങളായി വിഭജിക്കാം:

  1. നോളേജ് ടൂളുകൾ:
  2. ആക്ഷൻ ടൂളുകൾ:

Agent Service ഈ ടൂളുകൾ toolset ആയി ഒരുമിച്ച് ഉപയോഗിക്കാൻ അനുവദിക്കുന്നു. ഇത് threads ഉപയോഗിക്കുന്നു, ഒരു പ്രത്യേക സംഭാഷണത്തിൽ നിന്നുള്ള സന്ദേശങ്ങളുടെ ചരിത്രം ട്രാക്ക് ചെയ്യുന്നു.

നിങ്ങൾ Contoso എന്ന കമ്പനിയിലെ ഒരു സെയിൽസ് ഏജന്റാണെന്ന് കരുതുക. നിങ്ങളുടെ സെയിൽസ് ഡാറ്റയെക്കുറിച്ചുള്ള ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകാൻ ഒരു സംഭാഷണ ഏജന്റിനെ വികസിപ്പിക്കാനാണ് നിങ്ങൾ ആഗ്രഹിക്കുന്നത്.

താഴെ കാണുന്ന ചിത്രം Azure AI Agent Service ഉപയോഗിച്ച് നിങ്ങളുടെ സെയിൽസ് ഡാറ്റ വിശകലനം ചെയ്യുന്നത് എങ്ങനെ ചെയ്യാമെന്ന് ചിത്രീകരിക്കുന്നു:

![Agentic Service In Action](./images/agent ആപ്ലിക്കേഷൻ ഒരു സുരക്ഷിത പരിസ്ഥിതിയിൽ പ്രവർത്തിപ്പിക്കുന്നത് സംരക്ഷണം കൂടുതൽ മെച്ചപ്പെടുത്തുന്നു. എന്റർപ്രൈസ് സാഹചര്യങ്ങളിൽ, ഡാറ്റ സാധാരണയായി ഓപ്പറേഷണൽ സിസ്റ്റങ്ങളിൽ നിന്ന് എടുക്കുകയും ഉപയോക്തൃ സൗഹൃദമായ സ്കീമയുള്ള ഒരു റീഡ്-ഓൺലി ഡാറ്റാബേസ് അല്ലെങ്കിൽ ഡാറ്റ വെയർഹൗസിലേക്ക് മാറ്റുകയും ചെയ്യുന്നു. ഈ സമീപനം ഡാറ്റ സുരക്ഷിതമാണെന്ന്, പ്രകടനത്തിനും ആക്സസിബിലിറ്റിക്കും അനുയോജ്യമാണെന്ന്, കൂടാതെ ആപ്ലിക്കേഷനിന് പരിമിതമായ, റീഡ്-ഓൺലി ആക്സസ് മാത്രമാണെന്ന് ഉറപ്പാക്കുന്നു.

സാമ്പിൾ കോഡുകൾ

ടൂൾ ഉപയോഗ ഡിസൈൻ പാറ്റേണുകൾക്കുറിച്ച് കൂടുതൽ ചോദ്യങ്ങളുണ്ടോ?

മറ്റു പഠിതാക്കളുമായി കൂടിക്കാഴ്ച നടത്താനും, ഓഫീസ് അവർസിൽ പങ്കെടുക്കാനും, നിങ്ങളുടെ AI ഏജന്റുകളുമായി ബന്ധപ്പെട്ട ചോദ്യങ്ങൾക്ക് ഉത്തരം ലഭിക്കാനും Azure AI Foundry Discord ചേരുക.

അധിക വിഭവങ്ങൾ

മുൻപത്തെ പാഠം

Agentic Design Patterns മനസ്സിലാക്കുക

അടുത്ത പാഠം

Agentic RAG

അസത്യവാദം:
ഈ രേഖ AI വിവർത്തന സേവനമായ Co-op Translator ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. കൃത്യതയ്ക്കായി ഞങ്ങൾ ശ്രമിക്കുന്നുവെങ്കിലും, ഓട്ടോമേറ്റഡ് വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റായ വിവരങ്ങൾ ഉണ്ടാകാൻ സാധ്യതയുണ്ട്. അതിന്റെ സ്വാഭാവിക ഭാഷയിലുള്ള മൗലിക രേഖ പ്രാമാണികമായ ഉറവിടമായി കണക്കാക്കണം. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മാനവ വിവർത്തനം ശുപാർശ ചെയ്യുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.

This site is open source. Improve this page.