Microsoft AI Agent Einführungskurs: Tools, die Design Patterns verwenden (aufrufen)

Werkzeuge sind interessant, weil sie KI-Intelligenzen ein breiteres Spektrum an Fähigkeiten ermöglichen. Durch das Hinzufügen von Werkzeugen ist die Intelligenz nicht mehr auf eine begrenzte Anzahl von Operationen beschränkt, die sie ausführen kann, sondern kann eine Vielzahl von Operationen durchführen. In diesem Kapitel werden wir uns mit dem Tool Usage Design Pattern beschäftigen, das beschreibt, wie eine KI-Intelligenz ein bestimmtes Tool verwenden kann, um ihre Ziele zu erreichen.

kurz

In diesem Kurs wollen wir die folgenden Fragen beantworten:

• Was sind Entwurfsmuster für die Verwendung von Werkzeugen?
• Für welche Anwendungsfälle kann es eingesetzt werden?
• Welche Elemente/Bausteine sind für die Umsetzung dieses Entwurfsmusters erforderlich?
• Welche besonderen Überlegungen gibt es bei der Verwendung von Tools zum Aufbau vertrauenswürdiger KI-Intelligenzen unter Verwendung von Entwurfsmustern?

Lernziel

Nach Abschluss dieses Kurses werden Sie in der Lage sein:

• Definieren Sie die Verwendung von Entwurfsmustern durch das Tool und deren Zweck.
• Identifizierung von Anwendungsfällen, in denen Entwurfsmuster für die Werkzeugverwendung Anwendung finden.
• Verstehen der Schlüsselelemente, die zur Implementierung dieses Entwurfsmusters erforderlich sind.
• Erkennen der Überlegungen zur Sicherstellung der Vertrauenswürdigkeit von KI-Intelligenzen bei der Verwendung dieses Entwurfsmusters.

Was sind Entwurfsmuster für die Verwendung von Werkzeugen?

Werkzeuge zur Verwendung von Entwurfsmustern Konzentriert sich darauf, Large Language Models (LLMs) die Möglichkeit zu geben, mit externen Tools zu interagieren, um bestimmte Ziele zu erreichen. Ein Tool ist ein Code, den eine Intelligenz ausführen kann, um eine Aktion durchzuführen. Bei Tools kann es sich um einfache Funktionen (z. B. Taschenrechner) oder um API-Aufrufe zu Diensten von Drittanbietern (z. B. Aktienkursabfragen oder Wettervorhersagen) handeln. Im Zusammenhang mit einer KI-Intelligenz sind Tools so konzipiert, dass sie von der Intelligenz als Reaktion auf eine Anforderung ausgeführt werden. Funktionsaufrufe für die Modellerstellung.

Für welche Anwendungsfälle kann es eingesetzt werden?

KI-Intelligenzen können Werkzeuge verwenden, um komplexe Aufgaben auszuführen, Informationen abzurufen oder Entscheidungen zu treffen. Das Entwurfsmuster "Tool Usage" wird typischerweise in Szenarien verwendet, die eine dynamische Interaktion mit externen Systemen wie Datenbanken, Webdiensten oder Code-Interpretern erfordern. Diese Funktion ist für viele verschiedene Anwendungsfälle nützlich, darunter:

• Dynamische Informationsbeschaffung: Intelligentsia kann externe APIs oder Datenbanken nach aktuellen Daten abfragen (z.B. Abfrage einer SQLite-Datenbank zur Datenanalyse, Abfrage von Aktienkursen oder Wetterinformationen).
• Ausführung und Interpretation des Codes: Intelligentsia kann Code oder Skripte ausführen, um mathematische Probleme zu lösen, Berichte zu erstellen oder Simulationen durchzuführen.
• Automatisierung des Arbeitsablaufs: Automatisieren Sie sich wiederholende oder mehrstufige Arbeitsabläufe durch die Integration von Tools wie Aufgabenplanern, E-Mail-Diensten oder Datenpipelines.
• Kundenbetreuung: Intelligentsia kann mit CRM-Systemen, Arbeitsauftragsplattformen oder Wissensdatenbanken interagieren, um Benutzeranfragen zu lösen.
• Erstellung und Bearbeitung von Inhalten: Intelligentsia kann Werkzeuge wie Grammatikprüfer, Textzusammenfassungen oder Inhaltssicherheitsprüfer einsetzen, um bei der Erstellung von Inhalten zu helfen.

Welche Elemente/Bausteine werden benötigt, um Werkzeuge zur Verwendung von Entwurfsmustern zu implementieren?

Diese Bausteine ermöglichen es KI-Intelligenzen, eine Vielzahl von Aufgaben zu erfüllen. Werfen wir einen Blick auf die Schlüsselelemente, die für die Implementierung eines Tools erforderlich sind, das Entwurfsmuster verwendet:

• Funktions-/WerkzeugaufrufeFunktionen: Dies ist die wichtigste Art und Weise, wie Large Language Models (LLMs) mit Werkzeugen interagieren können. Funktionen oder Werkzeuge sind wiederverwendbare Codeblöcke, die Intelligenzen zur Ausführung von Aufgaben verwenden. Dabei kann es sich um einfache Funktionen (z. B. Taschenrechner) oder um API-Aufrufe zu Diensten von Drittanbietern (z. B. Aktienkursabfragen oder Wettervorhersagen1 ) handeln.
• Dynamischer InformationsabrufIntelligentsia kann externe APIs oder Datenbanken nach den neuesten Daten abfragen. Dies ist nützlich für Aufgaben wie Datenanalyse, Abrufen von Aktienkursen oder Wetterinformationen1.
• Codeausführung und -interpretationIntelligentsia kann Code oder Skripte ausführen, um mathematische Probleme zu lösen, Berichte zu erstellen oder Simulationen durchzuführen 1.
• Automatisierung von ArbeitsabläufenDies beinhaltet die Automatisierung von sich wiederholenden oder mehrstufigen Arbeitsabläufen durch die Integration von Tools wie Aufgabenplanern, E-Mail-Diensten oder Datenpipelines1.
• Kundenbetreuung: Intelligenz kann mit CRM-Systemen, Arbeitsauftragsplattformen oder Wissensdatenbanken interagieren, um Benutzeranfragen zu lösen 1.
• Inhaltserstellung und -bearbeitung: Intelligentsia kann Werkzeuge wie Grammatikprüfer, Textzusammenfassungen oder Inhaltssicherheitsprüfer einsetzen, um bei der Erstellung von Inhalten zu helfen.

Als Nächstes wollen wir uns die Funktions-/Werkzeugaufrufe genauer ansehen.

Funktions-/Werkzeugaufrufe

Funktionsaufrufe sind das wichtigste Mittel, mit dem wir Large Language Models (LLMs) die Interaktion mit Tools ermöglichen. Sie werden oft sehen, dass "Funktion" und "Werkzeug" austauschbar verwendet werden, weil "Funktionen" (wiederverwendbare Codeblöcke) die "Werkzeuge" sind, die Intelligenzen zur Ausführung von Aufgaben verwenden. Werkzeuge". Um den Code einer Funktion aufzurufen, muss das Large Language Model (LLM) die Anfrage des Benutzers mit der Beschreibung der Funktion vergleichen. Zu diesem Zweck wird ein Schema mit allen verfügbaren Funktionsbeschreibungen an das LLM gesendet. Das Large Language Model (LLM) wählt dann die Funktion aus, die der Aufgabe am besten entspricht, und gibt deren Namen und Parameter zurück. Die ausgewählte Funktion wird aufgerufen und ihre Antwort wird an das Large Language Model (LLM) zurückgesendet, das diese Informationen verwendet, um auf die Anfrage des Benutzers zu antworten.

Für Entwickler, die Funktionsaufrufe für Intelligenzen implementieren, benötigen Sie:

1. Large Language Model (LLM)-Modell mit Unterstützung für Funktionsaufrufe
2. Muster mit Funktionsbeschreibungen
3. Code für jede beschriebene Funktion

Zur Veranschaulichung ein Beispiel für die Ermittlung der aktuellen Uhrzeit einer Stadt:

1. Initialisieren Sie das Large Language Model (LLM), das Funktionsaufrufe unterstützt:
   Nicht alle Modelle unterstützen Funktionsaufrufe, daher ist es wichtig, dass Sie überprüfen, ob das von Ihnen verwendete Large Language Model (LLM) dies unterstützt.Azure OpenAI Unterstützung für Funktionsaufrufe. Wir können damit beginnen, den Azure OpenAI-Client zu initialisieren.

   # 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. Erstellen von Funktionsmustern::
   Als Nächstes definieren wir ein JSON-Schema, das den Namen der Funktion, eine Beschreibung der Funktion und die Namen und Beschreibungen der Parameter der Funktion enthält. Dieses Schema wird dann zusammen mit der Anfrage des Benutzers an den zuvor erstellten Client weitergeleitet, um die Uhrzeit in San Francisco zu ermitteln. Es ist wichtig zu beachten, dass die Rückgabe der Werkzeug Aufruf(math.) Gattungstatt Die endgültige Antwort auf die Frage. Wie bereits erwähnt, gibt das Large Language Model (LLM) den Namen der Funktion zurück, die es für die Aufgabe ausgewählt hat, sowie die Argumente, die an die Funktion übergeben werden.

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

1. Der Code der Funktion, die zur Durchführung der Aufgabe erforderlich ist:
   Nachdem das Large Language Model (LLM) die auszuführende Funktion ausgewählt hat, muss nun der Code zur Ausführung der Aufgabe implementiert und ausgeführt werden. Wir können Code implementieren, um die aktuelle Zeit in Python zu ermitteln. Wir müssen auch Code schreiben, um den Namen und die Parameter aus der response_message zu extrahieren, um das Endergebnis zu erhalten.

   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.
   

Funktionsaufrufe sind das Herzstück der meisten (wenn nicht aller) Smartbody-Tools, aber sie von Grund auf zu implementieren kann manchmal eine Herausforderung sein. Wie wir in der Lektion 2 Wie wir gelernt haben, stellt uns das Agentic-Framework vorgefertigte Bausteine zur Verfügung, die den Einsatz von Tools ermöglichen.

Beispiele für den Einsatz von Werkzeugen mit dem Agentic Framework

Im Folgenden finden Sie einige Beispiele für die Verwendung von Entwurfsmustern mit verschiedenen Tools zur Implementierung eines agentenbasierten Frameworks:

Semantischer Kern

Semantic Kernel ist ein Open-Source-KI-Framework für .NET-, Python- und Java-Entwickler, die große Sprachmodelle (LLMs) verwenden. NET-, Python- und Java-Entwickler, die große Sprachmodelle (Large Language Models, LLMs) verwenden. Serialisierung Prozess beschreibt Ihre Funktion und ihre Argumente automatisch für das Modell und vereinfacht so den Prozess der Funktionsaufrufe. Außerdem wird die Hin- und Rückkommunikation zwischen dem Modell und Ihrem Code abgewickelt. Ein weiterer Vorteil der Verwendung eines agentenbasierten Frameworks wie Semantic Kernel ist, dass es Ihnen den Zugriff auf vorgefertigte Tools wie das Suche nach Dokumenten im Gesang antworten Code-Dolmetscher.

Das folgende Diagramm veranschaulicht den Prozess der Funktionsaufrufe mit dem Semantischen Kernel:

Im Semantischen Kernel werden die Funktionen/Werkzeuge als einfügenStückchen. Wir können dies tun, indem wir das, was wir zuvor gesehen haben, mit der get_current_time Funktion in eine Klasse importieren und diese Funktion darin platzieren, wodurch sie in ein Plugin umgewandelt wird. Wir können auch die kernel_function Dekorator, der die Beschreibung der Funktion annimmt. Wenn Sie dann den Kernel mit dem GetCurrentTimePlugin erstellen, serialisiert der Kernel automatisch die Funktion und ihre Argumente, um das Schema zu erstellen, das im Prozess an das Large Language Model (LLM) gesendet wird.

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 ist ein neueres Agenten-Framework, das es Entwicklern ermöglicht, hochwertige, skalierbare KI-Intelligenzen sicher zu erstellen, bereitzustellen und zu skalieren, ohne die zugrunde liegenden Rechen- und Speicherressourcen zu verwalten. Er ist besonders nützlich für Unternehmensanwendungen, da es sich um einen vollständig verwalteten Dienst mit Sicherheit auf Unternehmensniveau handelt.

Der Azure AI Agent Service bietet mehrere Vorteile gegenüber der direkten Entwicklung mit der Large Language Model (LLM) API, darunter:

• Automatisierte Tool-Aufrufe - keine Notwendigkeit, Tool-Aufrufe zu analysieren, Tools aufzurufen und Antworten zu verarbeiten; all dies wird jetzt serverseitig erledigt!
• Sicher verwaltete Daten - Sie können sich darauf verlassen, dass die Threads alle benötigten Informationen speichern, anstatt Ihren eigenen Dialogstatus zu verwalten
• Sofort einsatzbereite Tools - Tools, die Sie zur Interaktion mit Datenquellen wie Bing, Azure AI Search und Azure Functions verwenden können.

Die im Azure AI Agent Service verfügbaren Tools können in zwei Kategorien unterteilt werden:

1. Wissenswerkzeuge:
   • Grundlegende Verarbeitung mit Bing Search
   • Suche nach Dokumenten
   • Azure AI Suche
2. Bedienungshilfen:
   • Funktionsaufruf
   • Code-Dolmetscher
   • Von OpenAI definierte Werkzeuge
   • Azure-Funktionen

Agent Service ermöglicht es uns, diese Werkzeuge gemeinsam zu nutzen als toolset. Es nutzt auch die threads um den Nachrichtenverlauf einer bestimmten Unterhaltung zu verfolgen.

Nehmen wir an, Sie sind ein Verkaufsagent der Contoso Corporation. Sie möchten einen Dialogagenten entwickeln, der Fragen zu Ihren Verkaufsdaten beantworten kann.

Das folgende Diagramm veranschaulicht, wie Sie den Azure AI Agent Service nutzen können, um Ihre Verkaufsdaten zu analysieren:

Um eines dieser Werkzeuge mit einem Dienst zu verwenden, können wir einen Client erstellen und ein Werkzeug oder einen Werkzeugsatz definieren. Um dies zu tun, können wir den folgenden Python-Code verwenden. Das Large Language Model (LLM) ist in der Lage, sich das Toolset anzusehen und zu entscheiden, ob eine vom Benutzer erstellte Funktion verwendet werden soll oder nicht. fetch_sales_data_using_sqlite_query oder einen vorgefertigten Code-Interpreter, je nach Wunsch des Benutzers.

import os
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from fecth_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
)

Welche besonderen Überlegungen gibt es bei der Verwendung von Tools zum Aufbau vertrauenswürdiger KI-Intelligenzen unter Verwendung von Entwurfsmustern?

Ein häufiges Problem bei dynamisch generiertem SQL für Large Language Models (LLMs) ist die Sicherheit, insbesondere das Risiko von SQL-Injection oder böswilligen Operationen wie Löschen oder Manipulationen der Datenbank. Diese Bedenken sind zwar legitim, können aber durch die richtige Konfiguration der Datenbankzugriffsrechte wirksam entschärft werden. Bei den meisten Datenbanken bedeutet dies, dass die Datenbank als schreibgeschützt konfiguriert wird. Bei Datenbankdiensten wie PostgreSQL oder Azure SQL sollten den Anwendungen schreibgeschützte (SELECT-)Rollen zugewiesen werden.

Der Schutz kann durch die Ausführung von Anwendungen in einer sicheren Umgebung weiter verbessert werden. In einem Unternehmensszenario werden Daten oft aus operativen Systemen extrahiert und in eine schreibgeschützte Datenbank oder ein Data Warehouse mit einem benutzerfreundlichen Schema umgewandelt. Dieser Ansatz gewährleistet, dass die Daten sicher sind, die Leistung und die Zugänglichkeit optimiert sind und dass Anwendungen nur einen eingeschränkten Lesezugriff haben.