Cours d'introduction à Microsoft AI Agent : Outils utilisant (invoquant) des modèles de conception (Design Patterns)

Les outils sont intéressants parce qu'ils permettent aux intelligences IA d'avoir un plus large éventail de capacités. En ajoutant des outils, l'intelligence n'est plus limitée à l'ensemble restreint d'opérations qu'elle peut effectuer, mais peut réaliser une grande variété d'opérations. Dans ce chapitre, nous étudierons le modèle d'utilisation des outils, qui décrit comment une intelligence artificielle peut utiliser un outil particulier pour atteindre ses objectifs.

bref

Dans ce cours, nous espérons répondre aux questions suivantes :

• Qu'est-ce qu'un modèle d'utilisation d'outil ?
• Quels sont les cas d'utilisation possibles ?
• Quels sont les éléments/éléments de base nécessaires à la mise en œuvre de ce modèle de conception ?
• Quelles sont les considérations particulières à prendre en compte lors de l'utilisation d'outils permettant de construire des intelligences IA de confiance à l'aide de modèles de conception ?

objectif d'apprentissage

A l'issue de ce cours, vous serez en mesure de :

• Définir l'utilisation par l'outil des modèles de conception et leur objectif.
• Identifier les cas d'utilisation pour lesquels les modèles d'utilisation des outils s'appliquent.
• Comprendre les éléments clés nécessaires à la mise en œuvre de ce modèle de conception.
• Reconnaître les éléments à prendre en compte pour garantir la fiabilité des intelligences artificielles lors de l'utilisation de ce modèle de conception.

Qu'est-ce qu'un modèle d'utilisation d'outil ?

Outils pour utiliser les modèles de conception L'objectif est de donner aux grands modèles de langage (LLM) la capacité d'interagir avec des outils externes afin d'atteindre des objectifs spécifiques. Un outil est un code qu'une intelligence peut exécuter pour réaliser une action. Les outils peuvent être de simples fonctions (par exemple, des calculatrices) ou des appels d'API à des services tiers (par exemple, des consultations de cours boursiers ou des prévisions météorologiques). Dans le contexte d'une intelligence artificielle, les outils sont conçus pour être exécutés par l'intelligence en réponse à une demande d'information. Appels de fonctions pour la génération de modèles.

Quels sont les cas d'utilisation possibles ?

Les intelligences artificielles peuvent utiliser des outils pour effectuer des tâches complexes, rechercher des informations ou prendre des décisions. Le modèle de conception Tool Usage est généralement utilisé dans des scénarios qui nécessitent une interaction dynamique avec des systèmes externes, tels que des bases de données, des services web ou des interprètes de code. Cette fonctionnalité est utile pour de nombreux cas d'utilisation différents, notamment :

• Recherche dynamique d'informations : Intelligentsia peut interroger des API ou des bases de données externes pour obtenir des données actualisées (par exemple, interroger une base de données SQLite pour l'analyse des données, obtenir les cours de la bourse ou des informations météorologiques).
• Exécution et interprétation du code : Intelligentsia peut exécuter des codes ou des scripts pour résoudre des problèmes mathématiques, générer des rapports ou effectuer des simulations.
• Automatisation des flux de travail : Automatisez les flux de travail répétitifs ou à plusieurs étapes en intégrant des outils tels que des planificateurs de tâches, des services de messagerie ou des pipelines de données.
• Soutien à la clientèle : Intelligentsia peut interagir avec les systèmes de gestion de la relation client (CRM), les plates-formes d'ordres de travail ou les bases de connaissances pour résoudre les questions des utilisateurs.
• Génération et édition de contenu : Intelligentsia peut utiliser des outils tels que des correcteurs de grammaire, des résumés de texte ou des évaluateurs de sécurité du contenu pour faciliter les tâches de création de contenu.

Quels sont les éléments/éléments nécessaires à la mise en œuvre d'outils permettant d'utiliser des modèles de conception ?

Ces blocs de construction permettent aux intelligences artificielles d'effectuer une grande variété de tâches. Examinons les éléments clés nécessaires à la mise en œuvre d'un outil utilisant des modèles de conception :

• Appels de fonctions/outilsLes fonctions ou outils sont des blocs de code réutilisables utilisés par les intelligences pour effectuer des tâches. Les fonctions ou outils sont des blocs de code réutilisables utilisés par les intelligences pour effectuer des tâches. Il peut s'agir de fonctions simples (par exemple, des calculatrices) ou d'appels d'API à des services tiers (par exemple, la consultation du cours des actions ou les prévisions météorologiques1 ).
• Recherche dynamique d'informationsIntelligentsia peut interroger des API ou des bases de données externes pour obtenir les données les plus récentes. Ceci est utile pour des tâches telles que l'analyse de données, l'obtention de cours boursiers ou d'informations météorologiques1.
• Exécution et interprétation du codeIntelligentsia peut exécuter des codes ou des scripts pour résoudre des problèmes mathématiques, générer des rapports ou effectuer des simulations 1.
• Automatisation des flux de travailL'automatisation des flux de travail : Il s'agit d'automatiser les flux de travail répétitifs ou à plusieurs étapes en intégrant des outils tels que des planificateurs de tâches, des services de messagerie ou des pipelines de données1.
• Soutien à la clientèleLes intelligences peuvent interagir avec les systèmes de gestion de la relation client, les plates-formes de commande ou les bases de connaissances pour répondre aux questions des utilisateurs. 1.
• Génération et édition de contenu : Intelligentsia peut utiliser des outils tels que des correcteurs de grammaire, des résumés de texte ou des évaluateurs de sécurité du contenu pour faciliter les tâches de création de contenu..

Examinons ensuite plus en détail les appels de fonctions et d'outils.

Appels de fonctions/outils

Les appels de fonction sont la principale façon de permettre aux grands modèles de langage (LLM) d'interagir avec les outils. Les termes "fonction" et "outil" sont souvent utilisés de manière interchangeable, car les "fonctions" (blocs de code réutilisables) sont les "outils" que les intelligences utilisent pour effectuer des tâches. outils". Afin d'invoquer le code d'une fonction, le Grand Modèle de Langage (LLM) doit comparer la demande de l'utilisateur avec la description de la fonction. À cette fin, un schéma contenant toutes les descriptions de fonctions disponibles est envoyé au LLM. Le Grand Modèle de Langage (GML) sélectionne alors la fonction qui convient le mieux à la tâche et renvoie son nom et ses paramètres. La fonction sélectionnée est appelée et sa réponse est renvoyée au grand modèle de langage (LLM), qui utilise ces informations pour répondre à la demande de l'utilisateur.

Pour les développeurs qui mettent en œuvre des appels de fonction pour les intelligences, vous avez besoin :

1. Modèle de grand langage (LLM) avec prise en charge des appels de fonction
2. Modèles contenant des descriptions de fonctions
3. Code pour chaque fonction décrite

Prenons un exemple pour obtenir l'heure actuelle d'une ville :

1. Initialiser le grand modèle de langage (LLM) qui prend en charge les appels de fonction :
   Tous les modèles ne prennent pas en charge les appels de fonction, il est donc important de vérifier que le Grand Modèle de Langage (LLM) que vous utilisez les prend en charge.Azure OpenAI Support pour les appels de fonction. Nous pouvons commencer par initialiser le client 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. Création de modèles de fonctions: :
   Ensuite, nous définirons un schéma JSON contenant le nom de la fonction, une description de la fonction, ainsi que les noms et descriptions des paramètres de la fonction. Nous prendrons ensuite ce schéma et le transmettrons avec la requête de l'utilisateur au client créé précédemment pour trouver l'heure à San Francisco. Il est important de noter que le retour de la fonction Appel d'outil(math.) genreplutôt que La réponse finale à la question. Comme nous l'avons déjà mentionné, le Grand Modèle de Langage (LLM) renvoie le nom de la fonction qu'il a choisie pour la tâche, ainsi que les arguments qui lui seront transmis.

# 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. Le code de la fonction nécessaire à l'exécution de la tâche :
   Maintenant que le Grand Modèle de Langage (LLM) a sélectionné la fonction qui doit être exécutée, le code permettant de réaliser la tâche doit être implémenté et exécuté. Nous pouvons implémenter un code pour obtenir l'heure actuelle en Python. Nous devons également écrire du code pour extraire le nom et les paramètres du message_réponse afin d'obtenir le résultat final.

   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.
   

Les appels de fonction sont au cœur de la plupart (sinon de la totalité) des conceptions d'utilisation d'outils corporels intelligents, mais leur mise en œuvre à partir de zéro peut parfois s'avérer difficile. Comme nous l'avons vu dans le Leçon 2 Comme nous l'avons appris, le cadre Agentic nous fournit des blocs de construction pré-construits pour permettre l'utilisation de l'outil.

Exemples d'utilisation d'outils dans le cadre d'Agentic

Voici quelques exemples d'utilisation de modèles de conception avec différents outils de mise en œuvre de cadres agentiques :

Noyau sémantique

Semantic Kernel est un cadre d'IA open source pour les développeurs .NET, Python et Java utilisant de grands modèles de langage (LLM). NET, Python et Java utilisant de grands modèles de langage (LLM). sérialisation décrit automatiquement votre fonction et ses arguments au modèle, simplifiant ainsi le processus d'utilisation des appels de fonction. Il gère également la communication entre le modèle et votre code. Un autre avantage de l'utilisation d'un cadre agentique tel que Semantic Kernel est qu'il vous permet d'accéder à des outils pré-construits tels que l'outil Recherche de documents répondre en chantant interprète de code.

Le diagramme suivant illustre le processus d'appel de fonctions à l'aide du Semantic Kernel :

Dans le noyau sémantique, les fonctions/outils sont appelés interposerLes pièces. Nous pouvons le faire en combinant ce que nous avons vu précédemment avec la fonction get_current_time dans une classe et y placer cette fonction, la transformant ainsi en plugin. Nous pouvons également importer la fonction kernel_function qui accepte la description de la fonction. Ensuite, lorsque vous créez le noyau à l'aide du GetCurrentTimePlugin, le noyau sérialise automatiquement la fonction et ses arguments pour créer le schéma qui sera envoyé au Large Language Model (LLM) au cours du processus.

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 est un nouveau cadre agentique conçu pour permettre aux développeurs de construire, déployer et mettre à l'échelle en toute sécurité des intelligences IA de haute qualité et évolutives sans gérer les ressources de calcul et de stockage sous-jacentes. Il est particulièrement utile pour les applications d'entreprise car il s'agit d'un service entièrement géré avec une sécurité de niveau entreprise.

Le service Azure AI Agent Service offre plusieurs avantages par rapport au développement direct avec l'API Large Language Model (LLM) :

• Appels d'outils automatisés - plus besoin d'analyser les appels d'outils, d'invoquer les outils et de traiter les réponses ; tout cela se fait désormais côté serveur !
• Des données gérées en toute sécurité - vous pouvez compter sur les threads pour stocker toutes les informations dont vous avez besoin, plutôt que de gérer votre propre état de dialogue.
• Outils prêts à l'emploi - Outils que vous pouvez utiliser pour interagir avec des sources de données telles que Bing, Azure AI Search et Azure Functions.

Les outils disponibles dans Azure AI Agent Service peuvent être divisés en deux catégories :

1. Outils de connaissance :
   • Utilisation de Bing Search pour le traitement de base
   • Recherche de documents
   • Azure AI Search
2. Outils d'exploitation :
   • appel de fonction
   • interprète de code
   • Outils définis par l'OpenAI
   • Azure Functions

Le service d'agent nous permet d'utiliser ces outils ensemble en tant que toolset. Il utilise également threads pour conserver l'historique des messages d'une conversation particulière.

Supposons que vous soyez un agent commercial de la société Contoso. Vous souhaitez développer un agent de dialogue capable de répondre à des questions sur vos données de vente.

Le diagramme suivant illustre comment vous pouvez utiliser Azure AI Agent Service pour analyser vos données de vente :

Pour utiliser l'un de ces outils avec un service, nous pouvons créer un client et définir un outil ou un ensemble d'outils. Pour ce faire, nous pouvons utiliser le code Python suivant. Le grand modèle de langage (LLM) sera en mesure d'examiner l'ensemble d'outils et de décider d'utiliser ou non une fonction créée par l'utilisateur. fetch_sales_data_using_sqlite_query ou un interprète de code préconstruit, en fonction de la demande de l'utilisateur.

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
)

Quelles sont les considérations particulières à prendre en compte lors de l'utilisation d'outils permettant de construire des intelligences IA de confiance à l'aide de modèles de conception ?

La sécurité est un problème commun aux SQL générés dynamiquement pour les grands modèles de langage (LLM), en particulier le risque d'injection SQL ou d'opérations malveillantes telles que la suppression ou l'altération de la base de données. Bien que ces préoccupations soient légitimes, elles peuvent être efficacement atténuées en configurant correctement les droits d'accès à la base de données. Pour la plupart des bases de données, il s'agit de configurer la base de données en lecture seule. Pour les services de base de données tels que PostgreSQL ou Azure SQL, des rôles de lecture seule (SELECT) doivent être attribués aux applications.

La protection peut être encore renforcée en exécutant les applications dans un environnement sécurisé. Dans un scénario d'entreprise, les données sont souvent extraites des systèmes opérationnels et transformées en base de données en lecture seule ou en entrepôt de données avec un schéma convivial. Cette approche garantit que les données sont sécurisées, optimisées en termes de performances et d'accessibilité, et que les applications ont un accès restreint en lecture seule.