ai-agents-for-beginners

How to Design Good AI Agents

(மேலே உள்ள படத்தை கிளிக் செய்து இந்த பாடத்தின் வீடியோவைப் பாருங்கள்)

கருவி பயன்பாட்டு வடிவமைப்பு முறை

கருவிகள் மிகவும் சுவாரஸ்யமானவை, ஏனெனில் அவை AI முகவர்களுக்கு பரந்த அளவிலான திறன்களை வழங்குகின்றன. முகவர் செய்யக்கூடிய செயல்களின் வரம்பு குறைந்ததாக இருந்தால், ஒரு கருவியைச் சேர்ப்பதன் மூலம், முகவர் இப்போது பரந்த அளவிலான செயல்களைச் செய்ய முடியும். இந்த அத்தியாயத்தில், AI முகவர்கள் தங்கள் இலக்குகளை அடைய குறிப்பிட்ட கருவிகளை எவ்வாறு பயன்படுத்த முடியும் என்பதை விவரிக்கும் கருவி பயன்பாட்டு வடிவமைப்பு முறையைப் பார்க்கப் போகிறோம்.

அறிமுகம்

இந்த பாடத்தில், கீழ்க்காணும் கேள்விகளுக்கு பதிலளிக்க முயற்சிக்கிறோம்:

கற்றல் இலக்குகள்

இந்த பாடத்தை முடித்த பிறகு, நீங்கள்:

கருவி பயன்பாட்டு வடிவமைப்பு முறை என்ன?

கருவி பயன்பாட்டு வடிவமைப்பு முறை LLMக்களுக்கு வெளிப்புற கருவிகளுடன் தொடர்பு கொண்டு குறிப்பிட்ட இலக்குகளை அடைய உதவுகிறது. கருவிகள் என்பது முகவரால் செயல்படுத்தக்கூடிய குறியீடாகும். ஒரு கருவி கணக்கீடு போன்ற எளிய செயல்பாடு அல்லது பங்கு விலை தேடல் அல்லது வானிலை முன்னறிவிப்பு போன்ற மூன்றாம் தரப்பு சேவைக்கு API அழைப்பு ஆகியவையாக இருக்கலாம். AI முகவர்களின் சூழலில், கருவிகள் மாதிரி உருவாக்கப்பட்ட செயல்பாட்டு அழைப்புகள்க்கு பதிலளிக்க முகவர்களால் செயல்படுத்தப்படுவதற்காக வடிவமைக்கப்பட்டுள்ளன.

இது எந்த பயன்பாடுகளுக்கு பொருந்தும்?

AI முகவர்கள் கருவிகளை பயன்படுத்தி சிக்கலான பணிகளை முடிக்க, தகவல்களை பெற அல்லது முடிவுகளை எடுக்க முடியும். கருவி பயன்பாட்டு வடிவமைப்பு முறை, தரவுத்தொகுப்புகள், வலை சேவைகள் அல்லது குறியீடு விளக்கிகள் போன்ற வெளிப்புற அமைப்புகளுடன் மாறுபடும் தொடர்பு தேவைப்படும் சூழல்களில் பெரும்பாலும் பயன்படுத்தப்படுகிறது. இது பல்வேறு பயன்பாடுகளுக்கு பயனுள்ளதாக இருக்கும், அவற்றில் சில:

கருவி பயன்பாட்டு வடிவமைப்பு முறையை செயல்படுத்த தேவையான கூறுகள்/கட்டமைப்புகள் என்ன?

இந்த கட்டமைப்புகள் AI முகவர்களுக்கு பரந்த அளவிலான பணிகளைச் செய்ய உதவுகின்றன. கருவி பயன்பாட்டு வடிவமைப்பு முறையை செயல்படுத்த தேவையான முக்கிய கூறுகளைப் பார்ப்போம்:

அடுத்ததாக, செயல்பாடு/கருவி அழைப்புகளை விரிவாகப் பார்ப்போம்.

செயல்பாடு/கருவி அழைப்புகள்

செயல்பாடு அழைப்புகள் என்பது பெரிய மொழி மாதிரிகள் (LLMs) கருவிகளுடன் தொடர்பு கொள்ள உதவுவதற்கான முதன்மை வழியாகும். ‘செயல்பாடு’ மற்றும் ‘கருவி’ ஆகியவை பரஸ்பரம் மாற்றி பயன்படுத்தப்படுவதைக் காணலாம், ஏனெனில் ‘செயல்பாடுகள்’ (மீண்டும் பயன்படுத்தக்கூடிய குறியீடுகளின் தொகுதிகள்) என்பது முகவர்கள் பணிகளைச் செய்ய பயன்படுத்தும் ‘கருவிகள்’ ஆகும். ஒரு செயல்பாட்டின் குறியீடு செயல்படுத்தப்படுவதற்காக, LLM பயனர் கோரிக்கையை செயல்பாடுகளின் விளக்கத்துடன் ஒப்பிட வேண்டும். இதற்காக, கிடைக்கக்கூடிய அனைத்து செயல்பாடுகளின் விளக்கங்களை உள்ளடக்கிய ஒரு திட்டம் LLMக்கு அனுப்பப்படுகிறது. LLM பின்னர் பணிக்கான மிகச் சரியான செயல்பாட்டைத் தேர்ந்தெடுத்து அதன் பெயர் மற்றும் அளவுருக்களைத் திருப்புகிறது. தேர்ந்தெடுக்கப்பட்ட செயல்பாடு செயல்படுத்தப்படுகிறது, அதன் பதில் LLMக்கு அனுப்பப்படுகிறது, இது தகவலைப் பயன்படுத்தி பயனர் கோரிக்கைக்கு பதிலளிக்கிறது.

முகவர்களுக்கு செயல்பாட்டு அழைப்புகளை செயல்படுத்த, டெவலப்பர்கள் தேவையானவை:

  1. செயல்பாட்டு அழைப்புகளை ஆதரிக்கும் LLM மாதிரி
  2. செயல்பாட்டு விளக்கங்களை உள்ளடக்கிய ஒரு திட்டம்
  3. விளக்கப்பட்ட ஒவ்வொரு செயல்பாட்டிற்கும் குறியீடு

சான்ஃபிரான்சிஸ்கோவில் தற்போதைய நேரத்தைப் பெறுவதற்கான உதாரணத்தைப் பயன்படுத்தி விளக்குவோம்:

  1. செயல்பாட்டு அழைப்புகளை ஆதரிக்கும் LLMஐ தொடங்குதல்:

    அனைத்து மாதிரிகளும் செயல்பாட்டு அழைப்புகளை ஆதரிக்காது, எனவே நீங்கள் பயன்படுத்தும் LLM அதைச் செய்யுமா என்பதைச் சரிபார்ப்பது முக்கியம். Azure OpenAI செயல்பாட்டு அழைப்புகளை ஆதரிக்கிறது. Azure OpenAI கிளையண்டை தொடங்குவதன் மூலம் தொடங்கலாம்.

     # Initialize the Azure OpenAI client
     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 பணிக்கான செயல்பாட்டின் பெயர் மற்றும் அதற்கு அனுப்பப்படும் அளவுருக்களை திருப்புகிறது.

     # Function description for the model to read
     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"],
                 },
             }
         }
     ]
    
      
     # Initial user message
     messages = [{"role": "user", "content": "What's the current time in San Francisco"}] 
      
     # First API call: Ask the model to use the function
       response = client.chat.completions.create(
           model=deployment_name,
           messages=messages,
           tools=tools,
           tool_choice="auto",
       )
      
       # Process the model's response
       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"})
    
      # Handle function calls
       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.")  
      
       # Second API call: Get the final response from the model
       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ல் கற்றது போல, முகவர் கட்டமைப்புகள் கருவி பயன்பாட்டை செயல்படுத்த முன்பணியமைக்கப்பட்ட கட்டமைப்புகளை வழங்குகின்றன.

முகவர் கட்டமைப்புகளுடன் கருவி பயன்பாட்டு உதாரணங்கள்

முகவர் கட்டமைப்புகளைப் பயன்படுத்தி கருவி பயன்பாட்டு வடிவமைப்பு முறையை எவ்வாறு செயல்படுத்தலாம் என்பதைப் பற்றிய சில உதாரணங்கள் இங்கே:

Semantic Kernel

Semantic Kernel என்பது பெரிய மொழி மாதிரிகளுடன் (LLMs) பணிபுரியும் .NET, Python மற்றும் Java டெவலப்பர்களுக்கான ஓப்பன்-சோர்ஸ் AI கட்டமைப்பாகும். இது உங்கள் செயல்பாடுகள் மற்றும் அவற்றின் அளவுருக்களை மாதிரிக்கு தானாக விளக்குவதன் மூலம் செயல்பாட்டு அழைப்புகளைப் பயன்படுத்தும் செயல்முறையை எளிதாக்குகிறது, இது serializing என அழைக்கப்படுகிறது. இது மாதிரி மற்றும் உங்கள் குறியீட்டுக்கு இடையிலான தொடர்பை நிர்வகிக்கிறது. Semantic Kernel போன்ற முகவர் கட்டமைப்பைப் பயன்படுத்துவதன் மற்றொரு நன்மை, File Search மற்றும் Code Interpreter போன்ற முன்பணியமைக்கப்பட்ட கருவிகளை அணுக அனுமதிக்கிறது.

Semantic Kernel உடன் செயல்பாட்டு அழைப்புகளின் செயல்முறையை விளக்கும் பின்வரும் வரைபடம்:

function calling

Semantic Kernelல் செயல்பாடுகள்/கருவிகள் Plugins என அழைக்கப்படுகின்றன. முந்தைய get_current_time செயல்பாட்டை ஒரு வகுப்பாக மாற்றி அதில் செயல்பாட்டை சேர்த்தால், அதை ஒரு plugin ஆக மாற்றலாம். kernel_function அலங்காரத்தை இறக்குமதி செய்யவும், இது செயல்பாட்டின் விளக்கத்தைப் பெறுகிறது. GetCurrentTimePlugin உடன் ஒரு kernel உருவாக்கும்போது, kernel தானாக செயல்பாட்டை மற்றும் அதன் அளவுருக்களை serialize செய்து, 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

# Create the kernel
kernel = Kernel()

# Create the plugin
get_current_time_plugin = GetCurrentTimePlugin(location)

# Add the plugin to the kernel
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

இந்த சேவையுடன் எந்த கருவிகளையும் பயன்படுத்த, ஒரு கிளையண்டை உருவாக்கி ஒரு கருவி அல்லது கருவி தொகுப்பை வரையறுக்கலாம். இதை நடைமுறையில் செயல்படுத்த, பின்வரும் Python குறியீட்டை பயன்படுத்தலாம். LLM, பயனர் உருவாக்கிய fetch_sales_data_using_sqlite_query செயல்பாட்டை அல்லது முன்பணியமைக்கப்பட்ட Code Interpreterஐ பயனர் கோரிக்கையின் அடிப்படையில் பயன்படுத்த முடியும்.

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 function which can be found in a fetch_sales_data_functions.py file.
from azure.ai.projects.models import ToolSet, FunctionTool, CodeInterpreterTool

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

# Initialize function calling agent with the fetch_sales_data_using_sqlite_query function and adding it to the toolset
fetch_data_function = FunctionTool(fetch_sales_data_using_sqlite_query)
toolset = ToolSet()
toolset.add(fetch_data_function)

# Initialize Code Interpreter tool and adding it to the toolset. 
code_interpreter = code_interpreter = CodeInterpreterTool()
toolset = ToolSet()
toolset.add(code_interpreter)

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

நம்பகமான AI முகவர்களை உருவாக்க கருவி பயன்பாட்டு வடிவமைப்பு முறையைப் பயன்படுத்துவதற்கான சிறப்பு கருத்துக்கள் என்ன?

LLMக்களால் தானாக உருவாக்கப்படும் SQLக்கு பொதுவான கவலை பாதுகாப்பு, குறிப்பாக SQL அப்பிளிக்கேஷனை ஒரு பாதுகாப்பான சூழலில் இயக்குவது பாதுகாப்பை மேலும் மேம்படுத்துகிறது. நிறுவன சூழல்களில், தரவுகள் பொதுவாக செயல்பாட்டு அமைப்புகளில் இருந்து எடுக்கப்பட்டு, பயனர் நட்பு ஸ்கீமாவுடன் ஒரு வாசிக்க மட்டுமே உள்ள தரவுத்தொகுப்பு அல்லது தரவWarehouse-க்கு மாற்றப்படுகின்றன. இந்த அணுகுமுறை தரவுகள் பாதுகாப்பாகவும், செயல்திறனுக்காகவும் மற்றும் அணுகுமுறை சீரமைக்கப்பட்டதாகவும் இருப்பதை உறுதிப்படுத்துகிறது, மேலும் அப்பிளிக்கேஷனுக்கு கட்டுப்படுத்தப்பட்ட, வாசிக்க மட்டுமே அணுகலை வழங்குகிறது.

கருவி பயன்பாட்டுக்கான வடிவமைப்பு முறைமைகள் குறித்து மேலும் கேள்விகள் உள்ளதா?

மற்ற பயிற்சியாளர்களை சந்திக்கவும், அலுவலக நேரங்களில் கலந்துரையாடவும் மற்றும் உங்கள் AI Agents தொடர்பான கேள்விகளுக்கு பதிலளிக்கவும் Azure AI Foundry Discord குழுவில் சேருங்கள்.

கூடுதல் வளங்கள்

முந்தைய பாடம்

Agentic Design Patterns-ஐ புரிந்துகொள்வது

அடுத்த பாடம்

Agentic RAG


குறிப்பு:
இந்த ஆவணம் Co-op Translator என்ற AI மொழிபெயர்ப்பு சேவையை பயன்படுத்தி மொழிபெயர்க்கப்பட்டுள்ளது. எங்கள் தரச்செயல்முறையை உறுதிப்படுத்த முயற்சிக்கிறோம், ஆனால் தானியக்க மொழிபெயர்ப்புகளில் பிழைகள் அல்லது தவறான தகவல்கள் இருக்கக்கூடும் என்பதை கவனத்தில் கொள்ளவும். அதன் தாய்மொழியில் உள்ள மூல ஆவணம் அதிகாரப்பூர்வ ஆதாரமாக கருதப்பட வேண்டும். முக்கியமான தகவல்களுக்கு, தொழில்முறை மனித மொழிபெயர்ப்பு பரிந்துரைக்கப்படுகிறது. இந்த மொழிபெயர்ப்பைப் பயன்படுத்துவதால் ஏற்படும் எந்த தவறான புரிதல்கள் அல்லது தவறான விளக்கங்களுக்கு நாங்கள் பொறுப்பல்ல.