Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Tools
KI-Agenten bieten Mehrwert, indem sie mit externen Tools und Datenquellen interagieren, um nützliche Aufgaben auszuführen APIs. Die richtige Strategie zur Tool-Integration wirkt sich direkt auf die Fähigkeiten, die Sicherheitslage und die langfristige Flexibilität Ihres Agenten aus.
Dieser Abschnitt hilft Ihnen, sich in der Tool-Integrationslandschaft zurechtzufinden, wobei der Schwerpunkt auf offenen Standards liegt, die Ihre Freiheit und Flexibilität maximieren. In diesem Abschnitt wird das [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) für die Toolintegration vorgestellt und Framework-spezifische Tools und spezialisierte Meta-Tools zur Verbesserung der Arbeitsabläufe von Agenten besprochen.
**In diesem Abschnitt:**
+ [Kategorien von Tools](tool-categories.md)
+ [Protokollbasierte Tools](protocol-based-tools-detailed.md)
+ [Framework-native Tools](framework-native-tools-detailed.md)
+ [Meta-Tools](meta-tools-detailed.md)
+ [Strategie zur Integration von Tools](tool-integration-strategy.md)
+ [Bewährte Sicherheitsmethoden für die Toolintegration](security-best-practices-for-tool-integration.md)
# Kategorien von Tools
Building Agent Systems umfasst drei Hauptkategorien von Tools.
## Auf Protokollen basierende Tools
[Protokollbasierte Tools](protocol-based-tools-detailed.md) verwenden standardisierte Protokolle für die Kommunikation: agent-to-tool
+ **MCP-Tools** — Offene Standardtools, die in allen Frameworks funktionieren und sowohl lokale als auch Remote-Ausführungsoptionen bieten.
+ **OpenAIFunktionsaufruf** — Proprietäre Tools, die spezifisch für OpenAI Modelle sind.
+ **AnthropicTools** — Eine Variante des OpenAI Funktionsaufrufs für proprietäre Tools, die spezifisch für Anthropic Claude-Modelle sind.
## Framework-native Tools
[Framework-native Tools](framework-native-tools-detailed.md) sind direkt in spezifische Agenten-Frameworks integriert:
+ **Strands Agents Tools** — Leichte quick-to-implement Tools, die spezifisch für das Strands Agents Framework sind.
+ LangChainPythonauf **Tools** basierende Tools, die eng in das LangChain Ökosystem integriert sind.
+ **LlamaIndexTools** — Tools, die für den Datenabruf und die interne LlamaIndex Verarbeitung optimiert sind.
## Meta-Tools
[Meta-Tools](meta-tools-detailed.md) verbessern die Arbeitsabläufe der Agenten, ohne direkt externe Maßnahmen ergreifen zu müssen:
+ **Workflow-Tools** — Verwalten Sie den Ausführungsablauf der Agenten, die Verzweigungslogik und die Statusverwaltung.
+ **Tools für Agentendiagramme** — Koordinieren Sie mehrere Agenten in komplexen Workflows.
+ **Speichertools — Sorgen** für die persistente Speicherung und den dauerhaften Abruf von Informationen über Agentensitzungen hinweg.
+ **Reflexionstools** — Ermöglichen es Agenten, ihre eigene Leistung zu analysieren und zu verbessern.
# Auf Protokollen basierende Tools
Wenn es um protokollbasierte Tools geht, bietet das [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) die umfassendste und flexibelste Grundlage für die Toolintegration. Wie im [AWS Open-Source-Blogbeitrag zur Interoperabilität von Agenten dargelegt, AWS hat sich](https://aws.amazon.com/blogs/opensource/open-protocols-for-agent-interoperability-part-1-inter-agent-communication-on-mcp/) das Unternehmen MCP als strategisches Protokoll zu eigen gemacht und aktiv zu seiner Entwicklung beigetragen.
In der folgenden Tabelle werden die Optionen für die Bereitstellung des MCP-Tools beschrieben.
|
|
| **Bereitstellungsmodell** | **Beschreibung** | **Ideal für** | **Implementierung** |
| --- |--- |--- |--- |
| Lokales Studio | Tools werden im gleichen Prozess wie der Agent ausgeführt | Entwicklung, Testen und einfache Tools | Schnelle Implementierung ohne Netzwerk-Overhead |
| Auf lokalen servergestützten Ereignissen (SSE) | Tools werden lokal ausgeführt, kommunizieren aber über HTTP | Komplexere lokale Tools mit getrennten Aufgabenbereichen | Bessere Isolierung, aber immer noch geringe Latenz |
| Remote-HTTP-Streamingfähig | Tools werden auf Remote-Servern ausgeführt | Produktionsumgebungen und gemeinsam genutzte Tools | Skalierbar und zentral verwaltet |
Für die Erstellung von SDKs MCP-Tools stehen die offiziellen MCP zur Verfügung:
+ [PythonSDK](https://github.com/modelcontextprotocol/python-sdk) — Umfassende Implementierung mit vollständiger Protokollunterstützung
+ [TypeScriptSDK](https://github.com/modelcontextprotocol/typescript-sdk) —JavaScript//TypeScriptImplementierung für Webanwendungen
+ [JavaSDK](https://github.com/modelcontextprotocol/java-sdk) — Java-Implementierung für Unternehmensanwendungen
Diese SDKs bieten die Bausteine für die Erstellung MCP-kompatibler Tools in Ihrer bevorzugten Sprache mit konsistenten Implementierungen der Protokollspezifikation.
[Darüber hinaus AWS hat MCP im SDK implementiert. Strands Agents](https://aws.amazon.com/blogs/opensource/introducing-strands-agents-an-open-source-ai-agents-sdk/) Das Strands Agents SDK bietet eine einfache Möglichkeit, MCP-kompatible Tools zu erstellen und zu verwenden. [Eine umfassende Dokumentation ist im Repository verfügbar. Strands Agents GitHub ](https://github.com/strands-agents) Für einfachere Anwendungsfälle oder wenn Sie außerhalb des Strands Agents Frameworks arbeiten, SDKs bietet das offizielle MCP direkte Implementierungen des Protokolls in mehreren Sprachen an.
## Sicherheitsfunktionen von MCP-Tools
Zu den Sicherheitsfunktionen der MCP-Tools gehören:
+ **OAuth 2.0/2.1-Authentifizierung — Authentifizierung** nach Industriestandard
+ Umfang der **Berechtigungen — Präzise Zugriffskontrolle für** Tools
+ Erkennung der Funktionen von **Tools — Dynamische Erkennung** verfügbarer Tools
+ **Strukturierte Fehlerbehandlung** — Konsistente Fehlermuster
## Erste Schritte mit MCP-Tools
Gehen Sie wie folgt vor, um MCP für die Toolintegration zu implementieren:
1. Erkunden Sie das [Strands AgentsSDK](https://strandsagents.com) für eine produktionsreife MCP-Implementierung.
1. Lesen Sie die [technische Dokumentation zu MCP, um die Kernkonzepte](https://modelcontextprotocol.io/) zu verstehen.
1. Verwenden Sie die in diesem [AWS Open-Source-Blogbeitrag](https://aws.amazon.com/blogs/opensource/introducing-strands-agents-an-open-source-ai-agents-sdk/) beschriebenen praktischen Beispiele.
1. Beginnen Sie mit einfachen lokalen Tools, bevor Sie zu Remote-Tools übergehen.
1. Treten Sie der [MCP-Community](https://github.com/modelcontextprotocol/modelcontextprotocol) bei, um die Entwicklung des Protokolls zu beeinflussen.
## Erkunden Sie Gateway AgentCore
[Amazon Bedrock AgentCore Gateway](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway.html) bietet Entwicklern eine einfache und sichere Möglichkeit, MCP-Tools und andere Zielendpunkte in großem Umfang zu entwickeln, bereitzustellen, zu entdecken und eine Verbindung zu ihnen herzustellen. Mit AgentCore Gateway können Entwickler AWS Lambda Funktionen und bestehende Services in MCP-kompatible Tools umwandeln APIs. Anschließend können sie diese Tools mit nur wenigen Codezeilen Agenten über AgentCore Gateway-Endpunkte zur Verfügung stellen. AgentCore Gateway unterstützt OpenAPISmithy, und Lambda als Eingabetypen und ist die einzige Lösung, die sowohl eine umfassende Eingangs- als auch Ausgangsauthentifizierung in einem vollständig verwalteten Service bietet.
# Framework-native Tools
Obwohl das [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) die flexibelste Grundlage bietet, bieten Framework-native Tools Vorteile für bestimmte Anwendungsfälle.
Das [Strands AgentsSDK](https://strandsagents.com) bietet Python basierte Tools, die sich durch ihr leichtes Design auszeichnen und nur minimalen Aufwand für einfache Operationen erfordern. Sie ermöglichen eine schnelle Implementierung und ermöglichen es Entwicklern, Tools mit nur wenigen Codezeilen zu erstellen. Darüber hinaus sind sie eng integriert, sodass sie nahtlos in das Strands Agents Framework integriert werden können.
Das folgende Beispiel zeigt, wie Sie mit Hilfe von ein einfaches Wetter-Tool erstellenStrands Agents. Entwickler können Python Funktionen schnell und mit minimalem Codeaufwand in Tools umwandeln, auf die Agenten zugreifen können, und automatisch die entsprechende Dokumentation aus dem Docstring der Funktion generieren.
`#Example of a simple Strands native tool`
`@tool`
`def weather(location: str) -> str:`
`"""Get the current weather for a location""" #`
`Implementation here`
`return f"The weather in {location} is sunny."`
Für schnelles Prototyping oder einfache Anwendungsfälle können Framework-native Tools die Entwicklung beschleunigen. Für Produktionssysteme bieten MCP-Tools jedoch eine bessere Interoperabilität und future Flexibilität als Framework-native Tools.
Die folgende Tabelle bietet einen Überblick über andere Framework-spezifische Tools.
|
|
| **Framework** | **Art des Werkzeugs** | **Vorteile** | **Überlegungen** |
| --- |--- |--- |--- |
| [https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat) | Funktionsdefinitionen | Starke Unterstützung für mehrere Agenten | MicrosoftÖkosystem |
| [https://python.langchain.com/docs/concepts/tools/](https://python.langchain.com/docs/concepts/tools/) | PythonKlassen | Großes Ökosystem vorgefertigter Tools | Bindung an ein Framework |
| [https://docs.llamaindex.ai/en/stable/getting_started/starter_tools/](https://docs.llamaindex.ai/en/stable/getting_started/starter_tools/) | Python-Funktionen | Optimiert für Datenoperationen | Beschränkt auf LlamaIndex |
# Meta-Tools
Meta-Tools interagieren nicht direkt mit externen Systemen. Stattdessen verbessern sie die Fähigkeiten der Agenten, indem sie Agentenmuster implementieren. In diesem Abschnitt werden Workflows, Agentendiagramme und Speicher-Metatools behandelt.
## Workflow-Metatools
Workflow-Metatools verwalten den Ablauf der Agentenausführung:
+ **Statusverwaltung** — Behalten Sie den Kontext über mehrere Agenteninteraktionen hinweg bei
+ **Verzweigungslogik** — Aktivieren Sie bedingte Ausführungspfade
+ **Wiederholungsmechanismen** — Behandeln Sie Fehler mit ausgeklügelten Wiederholungsstrategien
[Zu den Beispiel-Frameworks mit Workflow-Meta-Tools gehören auch [https://github.com/langchain-ai/langgraph](https://github.com/langchain-ai/langgraph)Workflow-Funktionen. Strands Agents](https://aws.amazon.com/blogs/opensource/introducing-strands-agents-an-open-source-ai-agents-sdk/)
## Metatools für Agentengraphen
Die Metatools für Agentengraphen koordinieren die Zusammenarbeit mehrerer Agenten:
+ **Delegierung von Aufgaben** — Weisen Sie spezialisierten Agenten Unteraufgaben zu
+ **Ergebnisaggregation** — Kombinieren Sie die Ergebnisse mehrerer Agenten
+ **Konfliktlösung — Beilegung** von Meinungsverschiedenheiten zwischen Agenten
Frameworks sind auf die Graphkoordination von Agenten [https://github.com/crewAIInc/crewAI](https://github.com/crewAIInc/crewAI)spezialisiert [https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat)und haben sich darauf spezialisiert.
## Speicher-Metatools
Speicher-Metatools ermöglichen persistentes Speichern und Abrufen:
+ **Konversationsverlauf** — Behalten Sie den Kontext zwischen den Sitzungen bei
+ **Wissensdatenbanken** — Speichern und Abrufen domänenspezifischer Informationen
+ **Vektorspeicher** — Ermöglichen semantische Suchfunktionen
Das Ressourcensystem von MCP bietet eine standardisierte Methode zur Implementierung von Speicher-Metatools, die über verschiedene Agenten-Frameworks hinweg funktionieren.
# Strategie zur Integration von Tools
Ihre Wahl der Tool-Integrationsstrategie wirkt sich direkt darauf aus, was Ihre Agenten erreichen können und wie einfach sich Ihr System weiterentwickeln kann. Priorisieren Sie offene Protokolle wie das [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) und setzen Sie gleichzeitig Framework-native Tools und Meta-Tools strategisch ein. Auf diese Weise können Sie ein Tool-Ökosystem aufbauen, das auch im Zuge der Weiterentwicklung der KI-Technologie flexibel und leistungsstark bleibt.
Der folgende strategische Ansatz zur Toolintegration maximiert die Flexibilität und erfüllt gleichzeitig die unmittelbaren Bedürfnisse Ihres Unternehmens:
1. **Nutzen Sie MCP als Grundlage** — MCP bietet eine standardisierte Möglichkeit, Agenten mit Tools mit starken Sicherheitsfunktionen zu verbinden. Beginnen Sie mit MCP als primärem Tool-Protokoll für:
+ Strategische Tools, die in mehreren Agentenimplementierungen eingesetzt werden.
+ Sicherheitsempfindliche Tools, die eine zuverlässige Authentifizierung und Autorisierung erfordern.
+ Tools, die in Produktionsumgebungen remote ausgeführt werden müssen.
1. **Verwenden Sie gegebenenfalls Framework-native Tools** — Ziehen Sie Framework-native Tools in Betracht für:
+ Schnelles Prototyping während der ersten Entwicklung.
+ Einfache, unkritische Tools mit minimalen Sicherheitsanforderungen.
+ Framework-spezifische Funktionen, die einzigartige Funktionen nutzen.
1. **Implementieren Sie Meta-Tools für komplexe Workflows** — Fügen Sie Meta-Tools hinzu, um Ihre Agentenarchitektur zu verbessern:
+ Beginnen Sie einfach mit grundlegenden Workflow-Mustern.
+ Erhöhen Sie die Komplexität, wenn Ihre Anwendungsfälle immer ausgereifter werden.
+ Standardisieren Sie die Schnittstellen zwischen Agenten und Meta-Tools.
1. **Für die Entwicklung planen** — mit Blick auf future Flexibilität bauen:
+ Dokumentieren Sie die Benutzeroberflächen der Tools unabhängig von den Implementierungen.
+ Erstellen Sie Abstraktionsebenen zwischen Agenten und Tools.
+ Richten Sie Migrationspfade von proprietären zu offenen Protokollen ein.
# Bewährte Sicherheitsverfahren für die Integration von Tools
Die Tool-Integration wirkt sich direkt auf Ihre Sicherheitslage aus. In diesem Abschnitt werden bewährte Methoden beschrieben, die Sie für Ihr Unternehmen berücksichtigen sollten.
## Authentifizierung und Autorisierung
Nutzen Sie die folgenden robusten Zugriffskontrollen:
+ **Verwenden Sie OAuth 2.0/2.1** — Implementieren Sie die branchenübliche Authentifizierung für Remote-Tools.
+ **Implementierung der geringsten Rechte** — Gewähren Sie Tools nur die Berechtigungen, die sie benötigen.
+ **Zugangsdaten wechseln** — Aktualisieren Sie regelmäßig API-Schlüssel und Zugriffstoken.
## Datenschutz
Ergreifen Sie zum Schutz Ihrer Daten die folgenden Maßnahmen:
+ **Eingaben und Ausgaben validieren** — Implementieren Sie die Schemavalidierung für alle Werkzeuginteraktionen.
+ **Vertrauliche Daten verschlüsseln** — Verwenden Sie TLS für die gesamte Remote-Tool-Kommunikation.
+ **Implementieren Sie Datenminimierung — Geben** Sie nur die erforderlichen Informationen an die Tools weiter.
## Überwachung und Prüfung
Sorgen Sie mit den folgenden Mechanismen für Transparenz und Kontrolle:
+ **Protokollieren Sie alle Tool-Aufrufe** — Pflegen Sie umfassende Prüfprotokolle.
+ **Auf Anomalien achten** — Erkennen Sie ungewöhnliche Nutzungsmuster von Tools.
+ **Implementieren Sie eine Ratenbegrenzung** — Beugen Sie Missbrauch durch übermäßige Tool-Aufrufe vor.
Das Sicherheitsmodell Model Context Protocol (MCP) geht umfassend auf diese Bedenken ein. Weitere Informationen finden Sie in der [MCP-Dokumentation unter Überlegungen zur Sicherheit](https://modelcontextprotocol.io/docs/concepts/architecture#security-considerations).