ai-agents-for-beginners

എങ്ങനെ നല്ല AI ഏജന്റുകൾ ഡിസൈൻ ചെയ്യാം

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

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

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

പരിചയം

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

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

ഈ പാഠം പൂർത്തിയായി കഴിഞ്ഞാൽ, നിങ്ങൾക്ക് കഴിയും:

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

ടൂൾ യൂസ് ഡിസൈൻ പാറ്റേൺ LLMs-ന് (ലാർജ് ലാംഗ്വേജ് മോഡലുകൾ) പ്രത്യേക ലക്ഷ്യങ്ങൾ നേടാൻ بيرിഹിത ടൂളുകളുമായി ഇടപെടാനുള്ള കഴിവ് നൽകുന്നതിന് ഊന്നൽ നൽകുന്നു. ടൂളുകൾ ഏജന്റ് നിർവ്വഹിക്കുന്ന കോഡുകളാണ്. ടൂൾ എന്നത് ഒരു ലളിതമായ ഫังก്ഷൻ ആയിരിക്കാം, ഉദാ: കാൽക്ക്യുലേറ്റർ, അല്ലെങ്കിൽ സ്റ്റോക്ക് വില അന്വേഷിക്കൽ അല്ലെങ്കിൽ കാലവസ്ഥ പ്രവചനത്തിന് ഏറ്റവുംപുറത്തുള്ള സേവനത്തിന്റെ API വിളി ആയിരിക്കാം. AI ഏജന്റുകൾക്കായി, ടൂളുകൾ മോഡൽ നിന്നുള്ള ഫങ്ക്ഷൻ കോളുകൾക്ക് പ്രതികരിച്ച് നടപ്പാക്കുന്നതിന് രൂപകൽപ്പന ചെയ്തതാണ്.

ഇത് ഏത് ഉപയോഗകേസുകളിൽ പ്രയോഗിക്കാം?

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

ടൂൾ യൂസ് ഡിസൈൻ പാറ്റേൺ നടപ്പിലാക്കാൻ ആവശ്യമുള്ള ഘടകങ്ങൾ/ബിൽഡിംഗ് ബ്ലോക്കുകൾ എന്തെല്ലാം?

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

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

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

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

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

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

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

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

    എല്ലാ മോഡലുകളും ഫംഗ്ഷൻ കോളിംഗ് പിന്തുണയ്ക്കുന്നില്ല, അതുകൊണ്ട് നിങ്ങൾ ഉപയോഗിക്കുന്ന LLM ഇത് ചെയ്യുമോ എന്നു പരിശോധിക്കുക പ്രധാനമാണ്. Azure OpenAI ഫംഗ്ഷൻ കോളിംഗ് പിന്തുണയ്ക്കുന്നു. OpenAI ക്ലയന്റ് തുടക്കം Azure OpenAI Responses API യെ പ്രതിസന്ധികരിച്ചാണ് (സ്ഥിരമായ /openai/v1/ എണ്ട്‌പോയിന്റ് — api_version ആവശ്യമില്ല).

     # Azure OpenAI (Responses API, v1 എൻഡ്പോയിന്റ്) için OpenAI ക്ലയന്റ് ആർഭത്രണ നിര്‍ദ്ദേശിക്കുക
 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. ഫംഗ്ഷൻ സ്കീമ നിർമിക്കുക:

    അടുത്തതായി, ഫംഗ്ഷന്റെ പേര്, നിർവചനവും ഫംഗ്ഷൻ പാരാമീറ്ററുകളുടെ പേര്, വിശദീകരണം എന്നിവ ഉള്ള ജേസൺ സ്കീമ നിർമിക്കും. ഈ സ്കീം മുമ്പ് സൃഷ്ടിച്ച ക്ലയന്റിന് അയച്ചു, ഉപയോക്താവിന്റെ ‘സാൻ ഫ്രാൻസിസ്കോയിൽ സമയം അറിയുക’ എന്ന അഭ്യർത്ഥനയ്ക്കൊപ്പം പറയും. ശ്രദ്ധിക്കേണ്ടത്, ടൂൾ കോളിംഗ് ആണ് ഫലമായി ലഭിക്കുന്നതും, ചോദ്യംക്ക് അവസാനം ഉത്തരമല്ല. മുൻപു പറഞ്ഞതുപോലെ, 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,
 )

 # Responses API ഫംഗ്ഷൻ_കാൾ ഇനങ്ങളായി ടൂൾ കോൾകൾ 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 ഉപയോഗിച്ച് ഇപ്പോഴത്തെ സമയം നേടാനുള്ള കോഡ് എഴുതി നടപ്പിലാക്കാം. മറുപടി സന്ദേശത്തിൽ നിന്നുള്ള പേര്, പാരാമീറ്ററുകൾ എടുക്കാനുള്ള കോഡും എഴുതണം അവസാന ഫലം നേടാൻ.

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

             # ഫംഗ്ഷൻ_കോള്ഔട്ട്‌പുട്ട് ഐറ്റംസായി ടൂൾ ഫലം തിരിച്ചു നൽകുക
             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 Agent Framework

Microsoft Agent Framework AI ഏജന്റുകൾ നിർമ്മിക്കാൻ ഒരു ഒപ്പൺ സോഴ്‌സ് AI ഫ്രെയിംവർക്കാണ്. ഫംഗ്ഷൻ കോളിങ് പ്രക്രിയ സുലഭമാക്കുന്നു, Python ഫംഗ്ഷനുകളെ @tool ഡെക്കറേറ്ററുമായി ടൂളുകളായി നിർവചിക്കാനാകുന്നു. മോഡലും നിങ്ങളുടെ കോഡും തമ്മിലുള്ള ആശയവിനിമയം ഈ ഫ്രെയിംവർക്കാണ് നിയന്ത്രിക്കുക. FoundryChatClient വഴി ഫയൽ തിരയൽ, കോഡ് ഇന്റർപ്രിറട്ടർ പോലുള്ള മുമ്പ് നിർമ്മിച്ച ടൂളുകൾ ആക്‌സസ് നൽകുന്നു.

Microsoft Agent Framework ഉപയോഗിച്ച് ഫംഗ്ഷൻ കോളിങ് പ്രക്രിയ താഴെ കാണിക്കുന്നത് പോലെ ആണ്:

function calling

Microsoft Agent Framework-ൽ, ടൂളുകൾ ഡെക്കറേറ്റുചെയ്ത ഫംഗ്ഷനുകളായി നിർവചിച്ചിരിക്കുന്നു. മുമ്പ് കണ്ട get_current_time ഫംഗ്ഷൻ @tool ഡെക്കറേറ്റർ ഉപയോഗിച്ച് ടൂൾ ആക്മക്കാം. ഫ്രെയിംവർക്കി അത് സ്വയം സീരിയലൈസ് ചെയ്ത്, 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 Agent Service

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

നേരിട്ട് LLM API- ഉപയോഗിച്ച് വികസിപ്പിക്കൽ തമ്മിൽ താരതമ്യം ചെയ്യുമ്പോൾ, Microsoft Foundry Agent Service-ന് ചില നേട്ടങ്ങൾ ഉണ്ട്, ഉദാഹരണത്തിന്:

Microsoft Foundry Agent Service-ലുള്ള ടൂളുകൾ രണ്ടു വിഭാഗത്തിലായി വിഭജിക്കാം:

  1. അറിവു ടൂളുകൾ:
  2. പ്രവർത്തന ടൂളുകൾ:

ഏജന്റ് സർവീസ് ഈ ടൂളുകൾ toolset ആയി ചേർത്ത് ഉപയോഗിക്കാൻ അനുവദിക്കുന്നു. കൂടാതെ, പ്രത്യേക സംഭാഷണത്തിൽ നിന്ന് സന്ദേശങ്ങളുടെ ചരിത്രം പിടിച്ചെടുക്കുന്ന threads ഉപയോഗിക്കുന്നു.

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

താഴെയുള്ള ചിത്രം Microsoft Foundry Agent Service ഉപയോഗിച്ച് നിങ്ങളുടെ സെയിൽസ് ഡേറ്റ നിർവചിക്കുന്ന വിധം കാണിക്കുന്നു:

Agentic Service In Action

ഈ സർവീസുകൾ ഉപയോഗിച്ച് ടൂളുകൾ ഉപയോഗിക്കാൻ ഒരു ക്ലയന്റ് സൃഷ്ടിച്ച് ടൂൾ അല്ലെങ്കിൽ ടൂൾസെറ്റ് നിർവചിക്കാം. പ്രായോഗികമായി ഇത് നടപ്പിലാക്കാൻ താഴെയുള്ള Python കോഡ് ഉപയോഗിക്കാം. LLM ടൂൾസെറ്റ് നോക്കി ഉപയോക്താവ് രചിച്ച ഫംഗ്ഷൻ 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)

# കോഡ് इंटरപ്രേറ്റർ ടൂൾ ആരംഭിച്ച് ടൂൾസെറ്റിലേക്ക് ചേർക്കുക.
code_interpreter = CodeInterpreterTool()toolset.add(code_interpreter)

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

വിശ്വസനീയ AI ഏജന്റുകൾ സൃഷ്ടിക്കാൻ ടൂൾ ഉപയോഗ ഡിസൈൻ പാറ്റേൺ ഉപയോഗിക്കുന്നതിന് പ്രത്യേക പരിഗണനകൾ എന്തൊക്കെയാണ്?

LLMs tərəfindən ഡൈനാമിക് ആയി സൃഷ്ടിച്ച SQL-ന് സുരക്ഷാ പ്രശ്നങ്ങൾ സാധാരണമാണ്, പ്രത്യേകിച്ച് SQL ഇൻജെക്ഷൻ, ദുർവ്യക്ഷങ്ങൾ പോലുള്ള അപകടങ്ങൾ, ഡാറ്റാബേസ് നശിപ്പിക്കൽ അല്ലെങ്കിൽ ചവറ്റി മാറ്റൽ പോലുള്ള പ്രവർത്തനങ്ങൾ. ഈ ആശങ്കകൾ ശരിയാണ്‌, എന്നാൽ ഡാറ്റാബേസ് ആക്സസ് അനുമതികൾ ശരിയായി ക്രമീകരിച്ച് ഇതു ഫലപ്രദമായി നിയന്ത്രിക്കാം. കൂടുതൽ ഡാറ്റാബേസുകൾക്ക് ഇത് വായന മാത്രമുള്ള റെഡ്-ഓൺലി ആയി ക്രമീകരിക്കേണ്ടതാണ്. PostgreSQL അല്ലെങ്കിൽ Azure SQL പോലുള്ള ഡാറ്റാബേസ് സേവനങ്ങൾക്കായി ആപ്പ് റീഡ്-ഓൺലി (SELECT) റോളും നൽകുന്നത് ആവശ്യമാണ്.

ആപ്പ് സുരക്ഷിതമായ പരിസരത്തിൽ ഓടിക്കുന്നത് കൂടുതൽ സംരക്ഷണം വർധിപ്പിക്കും. എന്റർപ്രൈസ് സാഹചര്യങ്ങളിൽ, ഡാറ്റ സാധാരണയായി പ്രവർത്തന സംവിധാനങ്ങളിൽ നിന്ന് എടുക്കുകയും മാറ്റം വരുത്തുകയും ചെയ്ത് വായന മാത്രമുള്ള ഡാറ്റാബേസ് അല്ലെങ്കിൽ ഡാറ്റാ വെയർഹൗസിലേക്ക് മാറ്റാറുണ്ട്, സൗഹൃദ സ്കീമയോടെ. ഇത്തരം സമീപനം ഡാറ്റ സുരക്ഷിതം ആകാൻ, പ്രകടനം മെച്ചപ്പെട്ടതും പ്രാപ്യതകൊണ്ടും ആക്കാനും, ആപ്പിന്റെ ആക്സസ് നിയന്ത്രിക്കപ്പെട്ട വായന മാത്രമുള്ള ആക്സസാണെന്ന് ഉറപ്പാക്കാനും സഹായിക്കുന്നു.

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

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

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

അധിക സ്രോതസ്സുകൾ

ഈ ഏജന്റിനെ സ്മോക്ക്-ടെസ്റ്റ് ചെയ്യുന്നത് (ഐച്ഛികം)

Lesson 16 ൽ ഏജന്റുകൾ വിന്യസിക്കാൻ പഠിച്ചതിന് ശേഷം, ഈ പാഠത്തിന്റെ TravelToolAgent (ഇ nadal ഉം അതിന്റെ ടൂളുകൾ വിളിക്കുന്നുണ്ടോ, മറുപടി നൽകുന്നുണ്ടോ?) tests/lesson-04-smoke-tests.json ഉപയോഗിച്ച് സ്മോക്ക്-ടെസ്റ്റ് ചെയ്യാം. ഇത് എങ്ങനെ നടത്താമെന്ന് കാണാൻ tests/README.md കാണുക.

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

ഏജന്റിക് ഡിസൈൻ പാറ്റേണുകൾ മനസ്സിലാക്കൽ

അടുത്ത പാഠം

ഏജന്റിക് RAG

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

This site is open source. Improve this page.