Curso introdutório do Microsoft AI Agent: Ferramentas que usam (invocam) padrões de design

As ferramentas são interessantes porque permitem que as inteligências de IA tenham uma gama mais ampla de recursos. Ao adicionar ferramentas, a inteligência não está mais limitada ao conjunto limitado de operações que pode realizar, mas pode realizar uma ampla variedade de operações. Neste capítulo, exploraremos o padrão de design de uso de ferramentas, que descreve como uma inteligência de IA pode usar uma ferramenta específica para atingir seus objetivos.

breve

Neste curso, esperamos responder às seguintes perguntas:

• O que são padrões de design de uso de ferramentas?
• Em quais casos de uso ele pode ser aplicado?
• Quais elementos/blocos de construção são necessários para implementar esse padrão de design?
• Quais são algumas considerações especiais sobre o uso de ferramentas para criar inteligências de IA confiáveis usando padrões de design?

meta de aprendizado

Após a conclusão deste curso, você será capaz de:

• Definir o uso de padrões de projeto pela ferramenta e sua finalidade.
• Identificar casos de uso em que os padrões de design de uso da ferramenta se aplicam.
• Compreender os principais elementos necessários para implementar esse padrão de design.
• Reconhecer as considerações para garantir a confiabilidade das inteligências de IA ao usar esse padrão de design.

O que são padrões de design de uso de ferramentas?

Ferramentas para usar padrões de design Concentra-se em dar aos modelos de linguagem grande (LLMs) a capacidade de interagir com ferramentas externas para atingir objetivos específicos. Uma ferramenta é um código que uma inteligência pode executar para realizar uma ação. As ferramentas podem ser funções simples (por exemplo, calculadoras) ou chamadas de API para serviços de terceiros (por exemplo, pesquisas de preços de ações ou previsões meteorológicas). No contexto de uma inteligência de IA, as ferramentas são projetadas para serem executadas pela inteligência em resposta a um Chamadas de função para geração de modelos.

Em quais casos de uso ele pode ser aplicado?

As inteligências de IA podem usar ferramentas para executar tarefas complexas, recuperar informações ou tomar decisões. O padrão de design Tool Usage é normalmente usado em cenários que exigem interação dinâmica com sistemas externos, como bancos de dados, serviços da Web ou interpretadores de código. Esse recurso é útil para muitos casos de uso diferentes, inclusive:

• Recuperação dinâmica de informações: A Intelligentsia pode consultar APIs ou bancos de dados externos para obter dados atualizados (por exemplo, consultar um banco de dados SQLite para análise de dados, obter preços de ações ou informações meteorológicas).
• Execução e interpretação do código: A Intelligentsia pode executar códigos ou scripts para resolver problemas matemáticos, gerar relatórios ou realizar simulações.
• Automação do fluxo de trabalho: Automatize fluxos de trabalho repetitivos ou de várias etapas integrando ferramentas como agendadores de tarefas, serviços de e-mail ou pipelines de dados.
• Suporte ao cliente: A Intelligentsia pode interagir com sistemas de CRM, plataformas de ordens de serviço ou bases de conhecimento para resolver as dúvidas dos usuários.
• Geração e edição de conteúdo: A Intelligentsia pode utilizar ferramentas como verificadores gramaticais, resumidores de texto ou avaliadores de segurança de conteúdo para ajudar nas tarefas de criação de conteúdo.

Quais elementos/blocos de construção são necessários para implementar uma ferramenta para usar padrões de design?

Esses blocos de construção permitem que as inteligências de IA executem uma ampla variedade de tarefas. Vamos dar uma olhada nos principais elementos necessários para implementar uma ferramenta que usa padrões de design:

• Chamadas de funções/ferramentasFunções ou ferramentas são blocos de código reutilizáveis que as inteligências usam para realizar tarefas. Funções ou ferramentas são blocos reutilizáveis de código que as inteligências usam para executar tarefas. Podem ser funções simples (por exemplo, calculadoras) ou chamadas de API para serviços de terceiros (por exemplo, pesquisas de preços de ações ou previsões meteorológicas1 ).
• Recuperação dinâmica de informaçõesIntelligentsia pode consultar APIs ou bancos de dados externos para obter os dados mais recentes. Isso é útil para tarefas como análise de dados, obtenção de preços de ações ou informações meteorológicas1.
• Execução e interpretação do códigoIntelligentsia: a Intelligentsia pode executar códigos ou scripts para resolver problemas matemáticos, gerar relatórios ou realizar simulações 1.
• Automação do fluxo de trabalhoAutomação de fluxos de trabalho repetitivos ou de várias etapas: isso envolve a automação de fluxos de trabalho repetitivos ou de várias etapas por meio da integração de ferramentas como agendadores de tarefas, serviços de e-mail ou pipelines de dados1.
• Suporte ao clienteInteligências: as inteligências podem interagir com sistemas de CRM, plataformas de ordens de serviço ou bases de conhecimento para resolver as dúvidas dos usuários 1.
• Geração e edição de conteúdo: a Intelligentsia pode utilizar ferramentas como verificadores gramaticais, resumidores de texto ou avaliadores de segurança de conteúdo para auxiliar nas tarefas de criação de conteúdo.

A seguir, vamos examinar as chamadas de função/ferramenta em mais detalhes.

Chamadas de funções/ferramentas

As chamadas de função são a principal maneira de permitir que os modelos de linguagem grande (LLMs) interajam com as ferramentas. Você verá com frequência o uso de "função" e "ferramenta" de forma intercambiável, pois as "funções" (blocos de código reutilizáveis) são as "ferramentas" que as inteligências usam para executar tarefas. ferramentas". Para invocar o código de uma função, o Modelo de Linguagem Ampla (LLM) deve comparar a solicitação do usuário com a descrição da função. Para isso, um esquema contendo todas as descrições de funções disponíveis é enviado ao LLM. Em seguida, o Modelo de Linguagem Grande (LLM) seleciona a função mais adequada à tarefa e retorna seu nome e parâmetros. A função selecionada é chamada e sua resposta é enviada de volta ao Large Language Model (LLM), que usa essas informações para responder à solicitação do usuário.

Para os desenvolvedores que implementam chamadas de função para inteligências, você precisa:

1. Modelo de linguagem grande (LLM) com suporte a chamadas de função
2. Padrões que contêm descrições de funções
3. Código para cada função descrita

Vamos ilustrar com um exemplo de obtenção da hora atual de uma cidade:

1. Inicialize o modelo de linguagem grande (LLM) que oferece suporte a chamadas de função:
   Nem todos os modelos oferecem suporte a chamadas de função, portanto, é importante verificar se o modelo de linguagem grande (LLM) que você está usando oferece esse suporte.Azure OpenAI Suporte para chamadas de função. Podemos começar inicializando o cliente 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. Criação de padrões de função::
   Em seguida, definiremos um esquema JSON que contém o nome da função, uma descrição da função da função e os nomes e descrições dos parâmetros da função. Em seguida, pegaremos esse esquema e o passaremos junto com a solicitação do usuário ao cliente criado anteriormente para encontrar a hora em São Francisco. É importante observar que o retorno da função Chamada de ferramenta(matemática) gêneroem vez de A resposta final à pergunta. Como mencionado anteriormente, o Large Language Model (LLM) retorna o nome da função escolhida para a tarefa, bem como os argumentos que serão passados a ela.

# 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. O código da função necessária para executar a tarefa:
   Agora que o Modelo de Linguagem Grande (LLM) selecionou a função que precisa ser executada, o código para realizar a tarefa precisa ser implementado e executado. Podemos implementar o código para obter a hora atual em Python. Também precisamos escrever código para extrair o nome e os parâmetros da response_message para obter o resultado 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.
   

As chamadas de função estão no centro da maioria (se não de todos) dos projetos de uso de ferramentas inteligentes para o corpo, mas implementá-las do zero às vezes pode ser um desafio. Como vimos na seção Lição 2 Como aprendemos, a estrutura Agentic nos fornece blocos de construção pré-construídos para permitir o uso da ferramenta.

Exemplos de uso de ferramentas usando a estrutura Agentic

Aqui estão alguns exemplos de como usar padrões de design com diferentes ferramentas de implementação de estruturas agênticas:

Núcleo semântico

O Semantic Kernel é uma estrutura de IA de código aberto para desenvolvedores de .NET, Python e Java que usam modelos de linguagem grandes (LLMs). NET, Python e desenvolvedores Java que usam modelos de linguagem grandes (LLMs). serialização O processo descreve automaticamente sua função e seus argumentos para o modelo, simplificando assim o processo de uso de chamadas de função. Ele também lida com a comunicação entre o modelo e seu código. Outra vantagem de usar uma estrutura agêntica como o Semantic Kernel é que ela permite acessar ferramentas pré-construídas, como o Pesquisa de documentos responder cantando interpretador de código.

O diagrama a seguir ilustra o processo de fazer chamadas de função usando o Semantic Kernel:

No Semantic Kernel, as funções/ferramentas são chamadas de interporPeças. Podemos fazer isso combinando o que vimos anteriormente com a função get_current_time em uma classe e colocar essa função nela, convertendo-a assim em um plug-in. Também podemos importar a classe kernel_function que aceita a descrição da função. Em seguida, quando você cria o kernel usando o GetCurrentTimePlugin, o kernel automaticamente serializa a função e seus argumentos para criar o esquema a ser enviado para o Large Language Model (LLM) no processo.

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)

Serviço de agente de IA do Azure

O Azure AI Agent Service é uma estrutura agêntica mais recente projetada para permitir que os desenvolvedores criem, implantem e dimensionem com segurança inteligências de IA escalonáveis e de alta qualidade sem gerenciar recursos subjacentes de computação e armazenamento. Ele é particularmente útil para aplicativos corporativos porque é um serviço totalmente gerenciado com segurança de nível empresarial.

O Serviço de Agente de IA do Azure oferece várias vantagens em relação ao desenvolvimento direto com a API LLM (Large Language Model), incluindo:

• Chamadas de ferramentas automatizadas - não há necessidade de analisar chamadas de ferramentas, invocar ferramentas e processar respostas; tudo isso agora é feito no lado do servidor!
• Dados gerenciados com segurança - você pode confiar nos threads para armazenar todas as informações de que precisa, em vez de gerenciar seu próprio estado de diálogo
• Ferramentas prontas para uso - ferramentas que você pode usar para interagir com fontes de dados, como Bing, Azure AI Search e Azure Functions.

As ferramentas disponíveis no Azure AI Agent Service podem ser divididas em duas categorias:

1. Ferramentas de conhecimento:
   • Uso do Bing Search para processamento básico
   • Pesquisa de documentos
   • Pesquisa de IA do Azure
2. Ferramentas operacionais:
   • chamada de função
   • interpretador de código
   • Ferramentas definidas pela OpenAI
   • Funções do Azure

O Agent Service nos permite usar essas ferramentas em conjunto como toolset. Ele também faz uso de threads para manter o controle do histórico de mensagens de uma determinada conversa.

Suponha que você seja um agente de vendas da Contoso Corporation. Você deseja desenvolver um agente de diálogo que possa responder a perguntas sobre seus dados de vendas.

O diagrama a seguir ilustra como você pode usar o Azure AI Agent Service para analisar seus dados de vendas:

Para usar qualquer uma dessas ferramentas com um serviço, podemos criar um cliente e definir uma ferramenta ou um conjunto de ferramentas. Para fazer isso, podemos usar o seguinte código Python. O modelo de linguagem grande (LLM) poderá examinar o conjunto de ferramentas e decidir se deve ou não usar uma função criada pelo usuário. fetch_sales_data_using_sqlite_query ou um interpretador de código pré-criado, dependendo da solicitação do usuário.

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
)

Quais são algumas considerações especiais sobre o uso de ferramentas para criar inteligências de IA confiáveis usando padrões de design?

Um problema comum com o SQL gerado dinamicamente para modelos de linguagem grande (LLMs) é a segurança, especificamente o risco de injeção de SQL ou operações mal-intencionadas, como exclusão ou adulteração do banco de dados. Embora essas preocupações sejam legítimas, elas podem ser atenuadas de forma eficaz com a configuração adequada dos direitos de acesso ao banco de dados. Para a maioria dos bancos de dados, isso envolve a configuração do banco de dados como somente leitura. Para serviços de banco de dados, como o PostgreSQL ou o Azure SQL, as funções somente leitura (SELECT) devem ser atribuídas aos aplicativos.

A proteção pode ser aprimorada ainda mais com a execução de aplicativos em um ambiente seguro. Em um cenário corporativo, os dados geralmente são extraídos de sistemas operacionais e transformados em um banco de dados somente leitura ou em um data warehouse com um esquema de fácil utilização. Essa abordagem garante que os dados estejam seguros, otimizados para desempenho e acessibilidade, e que os aplicativos tenham acesso restrito somente para leitura.