ai-agents-for-beginners

Ako navrhnúť dobrých AI agentov

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

Dizajnový vzor 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ý súbor akcií, ktoré môže vykonať, pridaním nástroja môže agent vykonávať širokú škálu akcií. V tejto kapitole sa pozrieme na Dizajnový vzor 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 vedieť:

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

Dizajnový vzor používania nástrojov sa zameriava na poskytnutie schopnosti LLM interagovať s externými nástrojmi na dosiahnutie konkrétnych cieľov. Nástroje sú kód, ktorý môže agent vykonať na realizáciu akcií. Nástroj môže byť jednoduchá funkcia ako kalkulačka, alebo volanie API tretej strany, napríklad vyhľadávanie cien akcií alebo predpoveď počasia. V kontexte AI agentov sú nástroje navrhnuté tak, aby ich agenti vykonávali ako reakciu na funkčné volania generované modelom.

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

AI agenti môžu využiť nástroje na dokončenie komplexných úloh, získavanie informácií alebo rozhodovanie. Dizajnový vzor 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 interpretery kódu. Táto schopnosť je užitočná pre rôzne prípady použitia, vrátane:

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

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

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

Volanie funkcií/nástrojov

Volanie funkcií je hlavným spôsobom, ktorým umožňujeme veľkým jazykovým modelom (LLM) interagovať s nástrojmi. Často uvidíte, že „Funkcia“ a „Nástroj“ sa používajú zameniteľne, pretože „funkcie“ (bloky znovupoužiteľného kódu) sú „nástroje“, ktoré agenti používajú na vykonávanie úloh. Aby sa kód funkcie mohol vyvolať, musí LLM porovnať požiadavku používateľa so špecifikáciou funkcie. Na to sa posiela schéma obsahujúca popisy všetkých dostupných funkcií LLM. LLM potom vyberie najvhodnejšiu funkciu pre úlohu a vráti jej názov a argumenty. Vybraná funkcia je vyvolaná, jej odpoveď je zaslaná späť LLM, ktoré používa tieto informácie na odpoveď na požiadavku používateľa.

Pre vývojárov, ktorí chcú implementovať volanie funkcií pre agentov, budete 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 ako ilustráciu:

  1. Inicializujte LLM, ktorý podporuje volanie funkcií:

    Nie všetky modely podporujú volanie funkcií, preto je dôležité skontrolovať, či LLM ktorý používate, túto funkciu má. Azure OpenAI podporuje volanie funkcií. Začneme vytvorením klienta Azure OpenAI.

     # Inicializujte klienta 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. Vytvorte schému 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 pošleme klientovi vytvorenému vyššie spolu s požiadavkou používateľa na zistenie času v San Franciscu. Dôležité je poznamenať, že sa vráti volanie nástroja, nie konečná odpoveď na otázku. Ako už bolo spomenuté, LLM vráti názov funkcie vybranej pre úlohu a argumenty, ktoré sa jej predajú.

     # Popis funkcie pre načítanie modelu
 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"],
             },
         }
     }
 ]

      
 # Počiatočná správa používateľa
 messages = [{"role": "user", "content": "What's the current time in San Francisco"}] 
  
 # Prvé volanie API: Požiadať model, aby použil funkciu
   response = client.chat.completions.create(
       model=deployment_name,
       messages=messages,
       tools=tools,
       tool_choice="auto",
   )
  
   # Spracovať odpoveď modelu
   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:

    Keď si LLM vyberie, ktorá funkcia sa musí spustiť, je potrebné implementovať a vykonať kód, ktorý úlohu zvládne. Môžeme implementovať kód na získanie aktuálneho času v Pythone. Tiež budeme 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"})

      # Spracujte volania funkcií
   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.")  
  
   # Druhé volanie API: Získajte konečnú odpoveď od modelu
   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 dizajnových vzorov používania nástrojov agentov, avšak jeho implementácia od základov môže byť občas náročná. Ako sme sa naučili v Lekcii 2, agentové rámce nám poskytujú predpripravené stavebné bloky pre implementáciu používania nástrojov.

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

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

Semantic Kernel

Semantic Kernel je open-source AI rámec pre .NET, Python a Java vývojárov pracujúcich 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 cez proces nazývaný serializácia. Tiež rieši komunikáciu tam a späť medzi modelom a vašim kódom. Ďalšou výhodou použitia agentového rámca ako Semantic Kernel je, že umožňuje prístup k predpripraveným nástrojom ako Vyhľadávanie súborov a Interpret kódu.

Nasledujúci diagram znázorňuje proces volania funkcií so Semantic Kernel:

volanie funkcie

V Semantic Kernel sa funkcie/nástroje nazývajú Pluginy. Môžeme previesť funkciu get_current_time, ktorú sme videli vyššie, na plugin tým, že ju premeníme na triedu s touto funkciou v nej. 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, ktorá sa pošle 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

# Vytvorte jadro
kernel = Kernel()

# Vytvorte doplnok
get_current_time_plugin = GetCurrentTimePlugin(location)

# Pridajte doplnok do jadra
kernel.add_plugin(get_current_time_plugin)

Azure AI Agent Service

Azure AI Agent Service je novší agentový rámec navrhnutý tak, aby umožnil vývojárom bezpečne vytvárať, nasadzovať a škálovať kvalitných a rozšíriteľných AI agentov bez potreby spravovať základné výpočtové a úložné zdroje. Je obzvlášť užitočný pre podnikové aplikácie, keďže je to plne spravovaná služba s podnikovej úrovne bezpečnosťou.

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

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

  1. Nástroje pre vedomosti:
  2. Nástroje pre akcie:

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

Predstavte si, že ste predajný agent v spoločnosti Contoso. Chcete vyvinúť konverzačného agenta, ktorý dokáže odpovedať na otázky týkajúce sa vašich predajných údajov.

Nasledujúci obrázok ilustruje, ako by ste mohli využiť Azure AI Agent Service na analýzu predajný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 toolset a rozhodnúť, či použije používateľom vytvorenú funkciu fetch_sales_data_using_sqlite_query, alebo predpripravený Interpret kódu podľa 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 # funkcia fetch_sales_data_using_sqlite_query, ktorá sa nachádza v súbore 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"],
)

# Inicializovať súpravu nástrojov
toolset = ToolSet()

# Inicializovať agenta na volanie funkcií s funkciou fetch_sales_data_using_sqlite_query a pridať ju do súpravy nástrojov
fetch_data_function = FunctionTool(fetch_sales_data_using_sqlite_query)
toolset.add(fetch_data_function)

# Inicializovať nástroj Code Interpreter a pridať ho do súpravy nástrojov.
code_interpreter = code_interpreter = CodeInterpreterTool()
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í dizajnového vzoru používania nástrojov na budovanie dôveryhodných AI agentov?

Bežnou obavou pri dynamicky generovanom SQL prostredníctvom LLM je bezpečnosť, najmä riziko SQL injekcie alebo škodlivých akcií, ako napríklad vymazanie alebo poškodenie databázy. Hoci sú tieto obavy oprávnené, dajú sa účinne zmierniť správnou konfiguráciou prístupových oprávnení k databáze. Pre väčšinu databáz to znamená nastavenie databázy ako len na čítanie. Pre databázové služby ako PostgreSQL alebo Azure SQL by mala aplikácia dostať rolu s prístupom len na čítanie (SELECT). Spustenie aplikácie v zabezpečenom prostredí ďalej zvyšuje ochranu. V podnikových scenároch sa údaje zvyčajne extrahujú a transformujú z prevádzkových systémov do databázy iba na čítanie alebo dátového skladu s používateľsky prívetivým schématom. Tento prístup zabezpečuje, že dáta sú chránené, optimalizované pre výkon a dostupnosť, a že aplikácia má obmedzený prístup iba na čítanie.

Ukážkové kódy

Máte ďalšie otázky o používateľských dizajnových vzoroch nástroja?

Pridajte sa k Azure AI Foundry Discord, kde sa môžete stretnúť s ostatnými študentmi, zúčastniť sa úradných hodín a získať odpovede na vaše otázky týkajúce sa AI Agentov.

Dodatočné zdroje

Predchádzajúca lekcia

Porozumenie agénskym dizajnovým vzorom

Nasledujúca lekcia

Agentic RAG

Vyhlásenie o zodpovednosti:
Tento dokument bol preložený pomocou AI prekladateľskej služby Co-op Translator. Aj keď sa snažíme o presnosť, prosím, berte na vedomie, že automatizované preklady môžu obsahovať chyby alebo nepresnosti. Originálny dokument v jeho pôvodnom 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.