ai-agents-for-beginners

Ako navrhnúť dobrých AI agentov

(Kliknite na obrázok vyššie pre zobrazenie videa k tejto lekcii)

Vzor návrhu používania nástrojov

Nástroje sú zaujímavé, pretože umožňujú AI agentom mať širší rozsah schopností. Namiesto toho, aby agent mal obmedzenú sadu akcií, ktoré môže vykonávať, pridaním nástroja môže agent vykonávať širokú škálu akcií. V tejto kapitole sa pozrieme na vzor návrhu používania nástrojov, ktorý popisuje, ako môžu AI agenti používať konkrétne nástroje na dosiahnutie svojich cieľov.

Úvod

V tejto lekcii sa snažíme odpovedať na nasledujúce otázky:

Ciele učenia

Po dokončení tejto lekcie budete schopní:

Čo je vzor návrhu používania nástrojov?

Vzor návrhu používania nástrojov sa zameriava na to, aby LLM mohli interagovať s externými nástrojmi na dosiahnutie konkrétnych cieľov. Nástroje sú kódy, ktoré môže agent vykonať na vykonanie akcií. Nástroj môže byť jednoduchá funkcia, ako napríklad kalkulačka, alebo API volanie na službu tretej strany, ako je vyhľadávanie cien akcií alebo predpoveď počasia. V kontexte AI agentov sú nástroje navrhnuté tak, aby ich agenti vykonávali v reakcii na modelom generované volania funkcií.

Na aké prípady použitia sa dá aplikovať?

AI agenti môžu využívať nástroje na dokončenie zložitých úloh, získavanie informácií alebo prijímanie rozhodnutí. Vzor návrhu používania nástrojov sa často používa v scenároch vyžadujúcich dynamickú interakciu s externými systémami, ako sú databázy, webové služby alebo interprety kódu. Táto schopnosť je užitočná pre množstvo rôznych prípadov použitia vrátane:

Aké sú prvky/stavebné bloky potrebné na implementáciu vzoru návrhu používania nástrojov?

Tieto stavebné bloky umožňujú AI agentovi vykonávať širokú škálu úloh. Pozrime sa na kľúčové prvky potrebné na implementáciu vzoru návrhu používania nástrojov:

Ďalej sa pozrime na volanie funkcií/nástrojov podrobnejšie.

Volanie funkcií/nástrojov

Volanie funkcií je primárny spôsob, ako umožniť veľkým jazykovým modelom (LLM) interagovať s nástrojmi. Často uvidíte, že pojmy „funkcia“ a „nástroj“ sa používajú zameniteľne, pretože „funkcie“ (bloky opakovane použiteľného kódu) sú „nástroje“, ktoré agenti používajú na vykonávanie úloh. Aby mohol byť kód funkcie vyvolaný, LLM musí porovnať požiadavku používateľa s popisom funkcie. Na tento účel sa LLM posiela schéma obsahujúca popisy všetkých dostupných funkcií. LLM potom vyberie najvhodnejšiu funkciu pre úlohu a vráti jej názov a argumenty. Vybraná funkcia sa vyvolá, jej odpoveď sa odošle späť LLM, ktorý použije informácie na odpoveď na požiadavku používateľa.

Na implementáciu volania funkcií pre agentov budú vývojári potrebovať:

  1. LLM model, ktorý podporuje volanie funkcií
  2. Schému obsahujúcu popisy funkcií
  3. Kód pre každú popísanú funkciu

Použime príklad získania aktuálneho času v meste na ilustráciu:

  1. Inicializácia LLM, ktorý podporuje volanie funkcií:

    Nie všetky modely podporujú volanie funkcií, preto je dôležité overiť, že LLM, ktorý používate, to umožňuje. Azure OpenAI podporuje volanie funkcií. Môžeme začať inicializáciou klienta 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. Vytvorenie schémy funkcie:

    Ďalej definujeme JSON schému, ktorá obsahuje názov funkcie, popis toho, čo funkcia robí, a názvy a popisy parametrov funkcie. Túto schému potom odovzdáme klientovi vytvorenému predtým spolu s požiadavkou používateľa na zistenie času v San Franciscu. Dôležité je si všimnúť, že sa vráti volanie nástroja, nie konečná odpoveď na otázku. Ako už bolo spomenuté, LLM vráti názov funkcie, ktorú vybral pre úlohu, a argumenty, ktoré sa jej odovzdajú.

     # 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. Kód funkcie potrebný na vykonanie úlohy:

    Teraz, keď LLM vybral, ktorá funkcia sa má spustiť, je potrebné implementovať a vykonať kód, ktorý úlohu vykoná. Môžeme implementovať kód na získanie aktuálneho času v Pythone. Budeme tiež musieť napísať kód na extrakciu názvu a argumentov z response_message, aby sme získali konečný výsledok.

       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.

Volanie funkcií je jadrom väčšiny, ak nie všetkých návrhov používania nástrojov agentov, avšak jeho implementácia od nuly môže byť niekedy náročná. Ako sme sa naučili v Lekcii 2, agentické rámce nám poskytujú predpripravené stavebné bloky na implementáciu používania nástrojov.

Príklady používania nástrojov s agentickými rámcami

Tu sú niektoré príklady, ako môžete implementovať vzor návrhu používania nástrojov pomocou rôznych agentických rámcov:

Semantic Kernel

Semantic Kernel je open-source AI rámec pre vývojárov v .NET, Pythone a Jave, ktorí pracujú s veľkými jazykovými modelmi (LLM). Zjednodušuje proces používania volania funkcií automatickým popisovaním vašich funkcií a ich parametrov modelu prostredníctvom procesu nazývaného serializácia. Tiež spravuje komunikáciu medzi modelom a vaším kódom. Ďalšou výhodou používania agentického rámca, ako je Semantic Kernel, je, že vám umožňuje prístup k predpripraveným nástrojom, ako sú File Search a Code Interpreter.

Nasledujúci diagram ilustruje proces volania funkcií so Semantic Kernel:

volanie funkcií

V Semantic Kernel sa funkcie/nástroje nazývajú Pluginy. Funkciu get_current_time, ktorú sme videli skôr, môžeme previesť na plugin tým, že ju premeníme na triedu s touto funkciou. Môžeme tiež importovať dekorátor kernel_function, ktorý prijíma popis funkcie. Keď potom vytvoríte kernel s GetCurrentTimePlugin, kernel automaticky serializuje funkciu a jej parametre, čím vytvorí schému na odoslanie 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 je novší agentický rámec navrhnutý na to, aby umožnil vývojárom bezpečne vytvárať, nasadzovať a škálovať vysoko kvalitných a rozšíriteľných AI agentov bez potreby spravovania základných výpočtových a úložných zdrojov. Je obzvlášť užitočný pre podnikové aplikácie, pretože ide o plne spravovanú službu s bezpečnosťou na úrovni podniku.

V porovnaní s vývojom priamo s LLM API poskytuje Azure AI Agent Service niektoré výhody, vrátane:

Nástroje dostupné v Azure AI Agent Service môžeme rozdeliť do dvoch kategórií:

  1. Nástroje na získavanie znalostí:
  2. Akčné nástroje:

Agent Service nám umožňuje používať tieto nástroje spoločne ako toolset. Tiež využíva threads, ktoré sledujú históriu správ z konkrétnej konverzácie.

Predstavte si, že ste obchodný agent v spoločnosti Contoso. Chcete vyvinúť konverzačného agenta, ktorý dokáže odpovedať na otázky o vašich obchodných údajoch.

Nasledujúci obrázok ilustruje, ako by ste mohli použiť Azure AI Agent Service na analýzu vašich obchodných údajov:

Agentická služba v akcii

Na použitie ktoréhokoľvek z týchto nástrojov so službou môžeme vytvoriť klienta a definovať nástroj alebo sadu nástrojov. Na praktickú implementáciu môžeme použiť nasledujúci Python kód. LLM bude schopný pozrieť sa na sadu nástrojov a rozhodnúť, či použiť používateľom vytvorenú funkciu fetch_sales_data_using_sqlite_query, alebo predpripravený Code Interpreter v závislosti od požiadavky používateľa.

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
)

Aké sú špeciálne úvahy pri používaní vzoru návrhu používania nástrojov na vytváranie dôveryhodných AI agentov?

Bežnou obavou pri SQL dynamicky generovanom LLM je bezpečnosť, najmä riziko SQL injekcie alebo škodlivých akcií, ako je vymazanie alebo manipulácia s databázou. Aj keď sú tieto obavy oprávnené, dajú sa efektívne zmierniť správnou konfiguráciou oprávnení na prístup k databáze. Pre väčšinu databáz to zahŕňa konfiguráciu databázy ako iba na čítanie. Pre databázové služby, ako sú PostgreSQL alebo Azure SQL, by mala byť aplikácii priradená rola iba na čítanie (SELECT).

Spustenie aplikácie v bezpečnom prostredí ďalej zvyšuje ochranu. V podnikových scenároch sa údaje zvyčajne extrahujú a transform Pridajte sa k Azure AI Foundry Discord, kde sa môžete stretnúť s ďalšími študentmi, zúčastniť sa konzultačných hodín a získať odpovede na otázky týkajúce sa AI Agentov.

Ďalšie zdroje

Predchádzajúca lekcia

Porozumenie agentickým návrhovým vzorom

Nasledujúca lekcia

Agentický RAG

Upozornenie:
Tento dokument bol preložený pomocou služby AI prekladu Co-op Translator. Hoci sa snažíme o presnosť, prosím, berte na vedomie, že automatizované preklady môžu obsahovať chyby alebo nepresnosti. Pôvodný dokument v jeho rodnom jazyku by mal byť považovaný za autoritatívny zdroj. Pre kritické informácie sa odporúča profesionálny ľudský preklad. Nie sme zodpovední za akékoľvek nedorozumenia alebo nesprávne interpretácie vyplývajúce z použitia tohto prekladu.

This site is open source. Improve this page.