ai-agents-for-beginners

(Klicka på bilden ovan för att se videon av denna lektion)

Designmönster för verktygsanvändning

Verktyg är intressanta eftersom de gör det möjligt för AI-agenter att ha ett bredare utbud av funktioner. Istället för att agenten har en begränsad uppsättning åtgärder den kan utföra, kan den genom att lägga till ett verktyg nu utföra en mängd olika åtgärder. I detta kapitel kommer vi att titta på designmönstret för verktygsanvändning, som beskriver hur AI-agenter kan använda specifika verktyg för att uppnå sina mål.

Introduktion

I denna lektion söker vi svar på följande frågor:

Vad är designmönstret för verktygsanvändning?
Vilka användningsområden kan det tillämpas på?
Vilka element/byggstenar behövs för att implementera designmönstret?
Vilka särskilda överväganden finns för att använda designmönstret för verktygsanvändning för att bygga pålitliga AI-agenter?

Lärandemål

Efter att ha genomfört denna lektion kommer du att kunna:

Definiera designmönstret för verktygsanvändning och dess syfte.
Identifiera användningsområden där designmönstret för verktygsanvändning är tillämpligt.
Förstå de viktigaste elementen som behövs för att implementera designmönstret.
Känna igen överväganden för att säkerställa tillförlitlighet hos AI-agenter som använder detta designmönster.

Vad är designmönstret för verktygsanvändning?

Designmönstret för verktygsanvändning fokuserar på att ge LLM:er förmågan att interagera med externa verktyg för att uppnå specifika mål. Verktyg är kod som kan köras av en agent för att utföra åtgärder. Ett verktyg kan vara en enkel funktion, såsom en kalkylator, eller ett API-anrop till en tredjepartstjänst, såsom att hämta aktiekurser eller väderprognoser. I sammanhanget av AI-agenter är verktyg designade för att köras av agenter som svar på modellgenererade funktionsanrop.

Vilka användningsområden kan det tillämpas på?

AI-agenter kan använda verktyg för att slutföra komplexa uppgifter, hämta information eller fatta beslut. Designmönstret för verktygsanvändning används ofta i scenarier som kräver dynamisk interaktion med externa system, såsom databaser, webbtjänster eller kodtolkare. Denna förmåga är användbar för ett antal olika användningsområden, inklusive:

Dynamisk informationshämtning: Agenter kan fråga externa API:er eller databaser för att hämta uppdaterad data (t.ex. fråga en SQLite-databas för dataanalys, hämta aktiekurser eller väderinformation).
Kodkörning och tolkning: Agenter kan köra kod eller skript för att lösa matematiska problem, generera rapporter eller utföra simuleringar.
Automatisering av arbetsflöden: Automatisera repetitiva eller flerstegsarbetsflöden genom att integrera verktyg som uppgiftsschemaläggare, e-posttjänster eller datapipelines.
Kundsupport: Agenter kan interagera med CRM-system, ärendehanteringsplattformar eller kunskapsbaser för att lösa användarfrågor.
Innehållsgenerering och redigering: Agenter kan använda verktyg som grammatikgranskare, textsammanfattare eller innehållssäkerhetsutvärderare för att hjälpa till med innehållsskapande uppgifter.

Vilka element/byggstenar behövs för att implementera designmönstret för verktygsanvändning?

Dessa byggstenar gör det möjligt för AI-agenten att utföra en mängd olika uppgifter. Låt oss titta på de viktigaste elementen som behövs för att implementera designmönstret för verktygsanvändning:

Funktions-/verktygsscheman: Detaljerade definitioner av tillgängliga verktyg, inklusive funktionsnamn, syfte, nödvändiga parametrar och förväntade utdata. Dessa scheman gör det möjligt för LLM att förstå vilka verktyg som är tillgängliga och hur man konstruerar giltiga förfrågningar.
Logik för funktionskörning: Styr hur och när verktyg anropas baserat på användarens avsikt och samtalskontext. Detta kan inkludera planeringsmoduler, routningsmekanismer eller villkorliga flöden som dynamiskt bestämmer verktygsanvändning.
System för meddelandehantering: Komponenter som hanterar samtalsflödet mellan användarinmatningar, LLM-svar, verktygsanrop och verktygsutdata.
Ramverk för verktygsintegration: Infrastruktur som ansluter agenten till olika verktyg, oavsett om de är enkla funktioner eller komplexa externa tjänster.
Felhantering och validering: Mekanismer för att hantera fel vid verktygskörning, validera parametrar och hantera oväntade svar.
Tillståndshantering: Spårar samtalskontext, tidigare verktygsinteraktioner och ihållande data för att säkerställa konsekvens över flera interaktioner.

Nästa steg är att titta närmare på funktions-/verktygsanrop.

Funktions-/verktygsanrop

Funktionsanrop är det primära sättet vi gör det möjligt för stora språkmodeller (LLM:er) att interagera med verktyg. Du kommer ofta att se “funktion” och “verktyg” användas omväxlande eftersom “funktioner” (block av återanvändbar kod) är de “verktyg” agenter använder för att utföra uppgifter. För att en funktions kod ska kunna köras måste en LLM jämföra användarens begäran med funktionsbeskrivningen. För att göra detta skickas ett schema som innehåller beskrivningarna av alla tillgängliga funktioner till LLM. LLM väljer sedan den mest lämpliga funktionen för uppgiften och returnerar dess namn och argument. Den valda funktionen körs, dess svar skickas tillbaka till LLM, som använder informationen för att svara på användarens begäran.

För att utvecklare ska kunna implementera funktionsanrop för agenter behöver du:

En LLM-modell som stöder funktionsanrop
Ett schema som innehåller funktionsbeskrivningar
Koden för varje funktion som beskrivs

Låt oss använda exemplet att få aktuell tid i en stad för att illustrera:

Initiera en LLM som stöder funktionsanrop:

Alla modeller stöder inte funktionsanrop, så det är viktigt att kontrollera att LLM du använder gör det. Azure OpenAI stöder funktionsanrop. Vi kan börja med att initiera Azure OpenAI-klienten.

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

Skapa ett funktionsschema:

Därefter definierar vi ett JSON-schema som innehåller funktionsnamnet, en beskrivning av vad funktionen gör, och namnen och beskrivningarna av funktionsparametrarna. Vi tar sedan detta schema och skickar det till den tidigare skapade klienten, tillsammans med användarens begäran att hitta tiden i San Francisco. Det som är viktigt att notera är att ett verktygsanrop är vad som returneras, inte det slutliga svaret på frågan. Som nämnts tidigare returnerar LLM namnet på den funktion den valde för uppgiften och de argument som kommer att skickas till den.

 # 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')])

Koden för funktionen som krävs för att utföra uppgiften:

Nu när LLM har valt vilken funktion som behöver köras måste koden som utför uppgiften implementeras och köras. Vi kan implementera koden för att få aktuell tid i Python. Vi måste också skriva koden för att extrahera namnet och argumenten från response_message för att få det slutliga resultatet.

   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.

Funktionsanrop är kärnan i de flesta, om inte alla, agenters verktygsanvändning, men att implementera det från grunden kan ibland vara utmanande. Som vi lärde oss i Lektion 2 ger agentiska ramverk oss förbyggda byggstenar för att implementera verktygsanvändning.

Exempel på verktygsanvändning med agentiska ramverk

Här är några exempel på hur du kan implementera designmönstret för verktygsanvändning med olika agentiska ramverk:

Semantic Kernel

Semantic Kernel är ett öppen källkods-AI-ramverk för .NET-, Python- och Java-utvecklare som arbetar med stora språkmodeller (LLM:er). Det förenklar processen för att använda funktionsanrop genom att automatiskt beskriva dina funktioner och deras parametrar för modellen genom en process som kallas serialisering. Det hanterar också kommunikationen fram och tillbaka mellan modellen och din kod. En annan fördel med att använda ett agentiskt ramverk som Semantic Kernel är att det låter dig komma åt förbyggda verktyg som File Search och Code Interpreter.

Följande diagram illustrerar processen för funktionsanrop med Semantic Kernel:

funktionsanrop

I Semantic Kernel kallas funktioner/verktyg Plugins. Vi kan konvertera funktionen get_current_time som vi såg tidigare till ett plugin genom att göra det till en klass med funktionen i den. Vi kan också importera dekoratorn kernel_function, som tar in beskrivningen av funktionen. När du sedan skapar en kernel med GetCurrentTimePlugin kommer kerneln automatiskt att serialisera funktionen och dess parametrar, och skapa schemat som ska skickas till LLM i processen.

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 är ett nyare agentiskt ramverk som är designat för att ge utvecklare möjlighet att säkert bygga, distribuera och skala högkvalitativa och utbyggbara AI-agenter utan att behöva hantera de underliggande beräknings- och lagringsresurserna. Det är särskilt användbart för företagsapplikationer eftersom det är en fullt hanterad tjänst med säkerhet i företagsklass.

Jämfört med att utveckla direkt med LLM API erbjuder Azure AI Agent Service några fördelar, inklusive:

Automatiska verktygsanrop – ingen behöver tolka ett verktygsanrop, köra verktyget och hantera svaret; allt detta görs nu server-side
Säker hantering av data – istället för att hantera din egen samtalshistorik kan du förlita dig på trådar för att lagra all information du behöver
Förbyggda verktyg – Verktyg som du kan använda för att interagera med dina datakällor, såsom Bing, Azure AI Search och Azure Functions.

Verktygen som finns tillgängliga i Azure AI Agent Service kan delas in i två kategorier:

Kunskapsverktyg:
Åtgärdsverktyg:

Agenttjänsten gör det möjligt för oss att använda dessa verktyg tillsammans som en toolset. Den använder också threads som håller reda på historiken av meddelanden från en viss konversation.

Föreställ dig att du är en försäljningsagent på ett företag som heter Contoso. Du vill utveckla en konversationsagent som kan svara på frågor om din försäljningsdata.

Följande bild illustrerar hur du kan använda Azure AI Agent Service för att analysera din försäljningsdata:

Agenttjänst i aktion

För att använda något av dessa verktyg med tjänsten kan vi skapa en klient och definiera ett verktyg eller en verktygssamling. För att implementera detta praktiskt kan vi använda följande Python-kod. LLM kommer att kunna titta på verktygssamlingen och avgöra om den ska använda den användarskapade funktionen, fetch_sales_data_using_sqlite_query, eller den förbyggda Code Interpreter beroende på användarens begäran.

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
)

Vilka särskilda överväganden finns för att använda designmönstret för verktygsanvändning för att bygga pålitliga AI-agenter?

En vanlig oro med SQL som dynamiskt genereras av LLM:er är säkerhet, särskilt risken för SQL-injektion eller skadliga åtgärder, såsom att radera eller manipulera databasen. Även om dessa bekymmer är giltiga kan de effektivt hanteras genom att korrekt konfigurera databasens åtkomstbehörigheter. För de flesta databaser innebär detta att konfigurera databasen som skrivskyddad. För databastjänster som PostgreSQL eller Azure SQL bör appen tilldelas en skrivskyddad (SELECT) roll. Att köra appen i en säker miljö förbättrar skyddet ytterligare. I företagsmiljöer extraheras och transformeras data vanligtvis från operativa system till en skrivskyddad databas eller datalager med ett användarvänligt schema. Denna metod säkerställer att data är säker, optimerad för prestanda och tillgänglighet, och att appen har begränsad, skrivskyddad åtkomst.

Har du fler frågor om verktygsanvändning och designmönster?

Gå med i Azure AI Foundry Discord för att träffa andra lärande, delta i öppet hus och få svar på dina frågor om AI-agenter.

Ytterligare resurser

Föregående lektion

Förstå agentiska designmönster

Nästa lektion

Agentic RAG

Ansvarsfriskrivning:
Detta dokument har översatts med hjälp av AI-översättningstjänsten Co-op Translator. Även om vi strävar efter noggrannhet, bör det noteras att automatiska översättningar kan innehålla fel eller felaktigheter. Det ursprungliga dokumentet på dess originalspråk bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för eventuella missförstånd eller feltolkningar som uppstår vid användning av denna översättning.

This site is open source. Improve this page.