# Princípios de Design de Agentes de IA

## Introdução

Existem muitas maneiras de pensar na construção de Sistemas de Agentes de IA. Considerando que a ambiguidade é uma característica, e não um defeito, no design de IA Generativa, às vezes é difícil para os engenheiros saberem por onde começar. Criamos um conjunto de Princípios de Design centrados no ser humano para permitir que os desenvolvedores construam sistemas de agentes centrados no cliente, capazes de atender às suas necessidades de negócios. Esses princípios de design não são uma arquitetura prescritiva, mas sim um ponto de partida para equipes que estão definindo e desenvolvendo experiências com agentes.

Em geral, os agentes devem:

- Ampliar e escalar as capacidades humanas (brainstorming, resolução de problemas, automação, etc.)
- Preencher lacunas de conhecimento (me atualizar em áreas de conhecimento, tradução, etc.)
- Facilitar e apoiar a colaboração nas formas como preferimos trabalhar com outras pessoas
- Nos tornar melhores versões de nós mesmos (por exemplo, coach de vida/gestor de tarefas, ajudando-nos a aprender habilidades de regulação emocional e mindfulness, construindo resiliência, etc.)

## Esta Aula Abrangerá

- O que são os Princípios de Design de Agentes
- Quais são algumas diretrizes a seguir ao implementar esses princípios de design
- Alguns exemplos de uso dos princípios de design

## Objetivos de Aprendizado

Após completar esta aula, você será capaz de:

1. Explicar o que são os Princípios de Design de Agentes
2. Explicar as diretrizes para o uso dos Princípios de Design de Agentes
3. Entender como construir um agente utilizando os Princípios de Design de Agentes

## Os Princípios de Design de Agentes

![Princípios de Design de Agentes](../../../translated_images/agentic-design-principles.9f32a64bb6e2aa5a1bdffb70111aa724058bc248b1a3dd3c6661344015604cff.pt.png?WT.mc_id=academic-105485-koreyst)

### Agente (Espaço)

Este é o ambiente no qual o agente opera. Esses princípios orientam como projetamos agentes para interagir nos mundos físico e digital.

- **Conectar, não substituir** – ajudar a conectar pessoas a outras pessoas, eventos e conhecimentos acionáveis para permitir colaboração e conexão.
  - Agentes ajudam a conectar eventos, conhecimentos e pessoas.
  - Agentes aproximam as pessoas. Eles não são projetados para substituir ou diminuir o papel das pessoas.
- **Facilmente acessível, mas ocasionalmente invisível** – o agente opera em grande parte em segundo plano e só nos alerta quando é relevante e apropriado.
  - O agente é facilmente descoberto e acessível para usuários autorizados em qualquer dispositivo ou plataforma.
  - O agente suporta entradas e saídas multimodais (som, voz, texto, etc.).
  - O agente pode alternar perfeitamente entre primeiro plano e segundo plano; entre proativo e reativo, dependendo da percepção das necessidades do usuário.
  - O agente pode operar de forma invisível, mas o caminho de seus processos em segundo plano e a colaboração com outros agentes são transparentes e controláveis pelo usuário.

### Agente (Tempo)

Este é o modo como o agente opera ao longo do tempo. Esses princípios orientam como projetamos agentes que interagem através do passado, presente e futuro.

- **Passado**: Refletindo sobre o histórico que inclui tanto estado quanto contexto.
  - O agente fornece resultados mais relevantes com base na análise de dados históricos mais ricos, indo além do evento, pessoas ou estados isolados.
  - O agente cria conexões a partir de eventos passados e reflete ativamente sobre a memória para lidar com situações atuais.
- **Agora**: Mais estímulos do que notificações.
  - O agente adota uma abordagem abrangente ao interagir com pessoas. Quando um evento ocorre, o agente vai além de uma notificação estática ou formalidade. Ele pode simplificar fluxos ou gerar dinamicamente dicas para direcionar a atenção do usuário no momento certo.
  - O agente entrega informações com base no ambiente contextual, mudanças sociais e culturais, e adaptadas à intenção do usuário.
  - A interação com o agente pode ser gradual, evoluindo/crescendo em complexidade para capacitar os usuários a longo prazo.
- **Futuro**: Adaptando-se e evoluindo.
  - O agente se adapta a vários dispositivos, plataformas e modalidades.
  - O agente se adapta ao comportamento do usuário, necessidades de acessibilidade e é totalmente personalizável.
  - O agente é moldado e evolui por meio da interação contínua com o usuário.

### Agente (Núcleo)

Esses são os elementos-chave no núcleo do design de um agente.

- **Aceitar incertezas, mas estabelecer confiança**.
  - Um certo nível de incerteza do agente é esperado. A incerteza é um elemento-chave no design de agentes.
  - Confiança e transparência são camadas fundamentais no design de agentes.
  - Os humanos têm controle sobre quando o agente está ativado/desativado, e o status do agente é claramente visível em todos os momentos.

## Diretrizes Para Implementar Esses Princípios

Ao usar os princípios de design acima, siga as seguintes diretrizes:

1. **Transparência**: Informe o usuário que a IA está envolvida, como ela funciona (incluindo ações passadas) e como fornecer feedback e modificar o sistema.
2. **Controle**: Permita que o usuário personalize, especifique preferências e personalize, tendo controle sobre o sistema e seus atributos (incluindo a capacidade de esquecer).
3. **Consistência**: Busque experiências consistentes e multimodais em dispositivos e pontos de contato. Use elementos familiares de UI/UX sempre que possível (por exemplo, ícone de microfone para interação por voz) e reduza a carga cognitiva do cliente tanto quanto possível (por exemplo, respostas concisas, recursos visuais e conteúdo "Saiba Mais").

## Como Projetar um Agente de Viagem Usando Esses Princípios e Diretrizes

Imagine que você está projetando um Agente de Viagem. Aqui está como você poderia pensar em usar os Princípios de Design e Diretrizes:

1. **Transparência** – Informe ao usuário que o Agente de Viagem é um Agente habilitado por IA. Forneça algumas instruções básicas sobre como começar (por exemplo, uma mensagem de "Olá", prompts de exemplo). Documente isso claramente na página do produto. Mostre a lista de prompts que o usuário fez no passado. Deixe claro como fornecer feedback (botões de curtir/descurtir, botão "Enviar Feedback", etc.). Articule claramente se o Agente tem restrições de uso ou tópicos.
2. **Controle** – Certifique-se de que esteja claro como o usuário pode modificar o Agente após sua criação, com coisas como o Prompt do Sistema. Permita que o usuário escolha o quão detalhado o Agente deve ser, seu estilo de escrita e quaisquer limitações sobre o que o Agente não deve abordar. Permita que o usuário visualize e exclua quaisquer arquivos ou dados associados, prompts e conversas anteriores.
3. **Consistência** – Certifique-se de que os ícones para Compartilhar Prompt, adicionar um arquivo ou foto e marcar alguém ou algo sejam padrões e reconhecíveis. Use o ícone de clipe de papel para indicar upload/compartilhamento de arquivos com o Agente, e um ícone de imagem para indicar upload de gráficos.

## Recursos Adicionais
- [Práticas para Governança de Sistemas de IA Agentes | OpenAI](https://openai.com)
- [O Projeto HAX Toolkit - Microsoft Research](https://microsoft.com)
- [Caixa de Ferramentas de IA Responsável](https://responsibleaitoolbox.ai)
```

**Aviso Legal**:
Este documento foi traduzido utilizando serviços de tradução baseados em IA. Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte oficial. Para informações críticas, recomenda-se a tradução humana profissional. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.


# Padrão de Design para Uso de Ferramentas

## Introdução

Nesta lição, vamos buscar responder às seguintes perguntas:

- O que é o padrão de design para uso de ferramentas?
- Quais são os casos de uso em que ele pode ser aplicado?
- Quais são os elementos/blocos de construção necessários para implementar esse padrão de design?
- Quais são as considerações especiais ao usar o padrão de design para uso de ferramentas para criar agentes de IA confiáveis?

## Objetivos de Aprendizado

Após concluir esta lição, você será capaz de:

- Definir o Padrão de Design para Uso de Ferramentas e seu propósito.
- Identificar casos de uso onde o padrão de design para uso de ferramentas é aplicável.
- Compreender os principais elementos necessários para implementar o padrão de design.
- Reconhecer considerações para garantir a confiabilidade de agentes de IA que utilizam esse padrão de design.

## O que é o Padrão de Design para Uso de Ferramentas?

O **Padrão de Design para Uso de Ferramentas** se concentra em fornecer aos LLMs a capacidade de interagir com ferramentas externas para atingir objetivos específicos. Ferramentas são códigos que podem ser executados por um agente para realizar ações. Uma ferramenta pode ser uma função simples, como uma calculadora, ou uma chamada de API para um serviço de terceiros, como consulta de preços de ações ou previsão do tempo. No contexto de agentes de IA, as ferramentas são projetadas para serem executadas por agentes em resposta a **chamadas de função geradas pelo modelo**.

## Quais são os casos de uso em que ele pode ser aplicado?

Agentes de IA podem aproveitar ferramentas para concluir tarefas complexas, recuperar informações ou tomar decisões. O padrão de design para uso de ferramentas é frequentemente usado em cenários que exigem interação dinâmica com sistemas externos, como bancos de dados, serviços web ou interpretadores de código. Essa capacidade é útil para diversos casos de uso, incluindo:

- **Recuperação Dinâmica de Informações:** Agentes podem consultar APIs externas ou bancos de dados para buscar dados atualizados (por exemplo, consultar um banco de dados SQLite para análise de dados, buscar preços de ações ou informações meteorológicas).
- **Execução e Interpretação de Código:** Agentes podem executar códigos ou scripts para resolver problemas matemáticos, gerar relatórios ou realizar simulações.
- **Automação de Fluxos de Trabalho:** Automatizar fluxos de trabalho repetitivos ou de múltiplas etapas integrando ferramentas como agendadores de tarefas, serviços de e-mail ou pipelines de dados.
- **Suporte ao Cliente:** Agentes podem interagir com sistemas CRM, plataformas de tickets ou bases de conhecimento para resolver dúvidas dos usuários.
- **Geração e Edição de Conteúdo:** Agentes podem usar ferramentas como verificadores gramaticais, resumos de texto ou avaliadores de segurança de conteúdo para auxiliar em tarefas de criação de conteúdo.

## Quais são os elementos/blocos de construção necessários para implementar o padrão de design para uso de ferramentas?

### Chamada de Função/Ferramenta

A chamada de função é a principal forma de permitir que Modelos de Linguagem de Grande Escala (LLMs) interajam com ferramentas. Muitas vezes, você verá "Função" e "Ferramenta" sendo usados de forma intercambiável, pois "funções" (blocos de código reutilizáveis) são as "ferramentas" que os agentes usam para realizar tarefas. Para que o código de uma função seja invocado, um LLM deve comparar a solicitação do usuário com a descrição da função. Para isso, um esquema contendo as descrições de todas as funções disponíveis é enviado ao LLM. O LLM seleciona a função mais apropriada para a tarefa e retorna seu nome e argumentos. A função selecionada é invocada, sua resposta é enviada de volta ao LLM, que usa as informações para responder à solicitação do usuário.

Para que os desenvolvedores implementem a chamada de função para agentes, você precisará de:

1. Um modelo LLM que suporte chamadas de função
2. Um esquema contendo descrições das funções
3. O código para cada função descrita

Vamos usar o exemplo de obter a hora atual em uma cidade para ilustrar:

- **Inicializar um LLM que suporte chamadas de função:**

    Nem todos os modelos suportam chamadas de função, então é importante verificar se o LLM que você está usando suporta. [Azure OpenAI](https://learn.microsoft.com/azure/ai-services/openai/how-to/function-calling) suporta chamadas de função. Podemos começar iniciando o cliente Azure OpenAI.

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

- **Criar um Esquema de Função:**

    Em seguida, definiremos um esquema JSON que contém o nome da função, uma descrição do que a função faz, e os nomes e descrições dos parâmetros da função. Depois, passaremos esse esquema ao cliente criado acima, juntamente com a solicitação do usuário para encontrar a hora em São Francisco. O que é importante notar é que uma **chamada de ferramenta** é o que é retornado, **não** a resposta final à pergunta. Como mencionado anteriormente, o LLM retorna o nome da função que selecionou para a tarefa e os argumentos que serão passados a ela.

    ```python
    # 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"],
                },
            }
        }
    ]
    ```

    ```python

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

    ```

    ```bash
    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')])
    ```

- **O código da função necessário para realizar a tarefa:**

    Agora que o LLM escolheu qual função precisa ser executada, o código que realiza a tarefa precisa ser implementado e executado. Podemos implementar o código para obter a hora atual em Python. Também precisaremos escrever o código para extrair o nome e os argumentos da `response_message` para obter o resultado final.

    ```python
      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"})
    ```

     ```python
     # 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
     ```

     ```bash
      get_current_time called with location: San Francisco
      Timezone found for san francisco
      The current time in San Francisco is 09:24 AM.
     ```

A chamada de função está no coração de grande parte, se não de toda, a concepção de uso de ferramentas por agentes. No entanto, implementá-la do zero pode ser desafiador. Como aprendemos na [Lição 2](../../../02-explore-agentic-frameworks), frameworks agentivos nos fornecem blocos de construção pré-configurados para implementar o uso de ferramentas.

### Exemplos de Uso de Ferramentas com Frameworks Agentivos

- ### **[Semantic Kernel](https://learn.microsoft.com/azure/ai-services/agents/overview)**

    O Semantic Kernel é um framework de IA de código aberto para desenvolvedores que trabalham com Modelos de Linguagem de Grande Escala (LLMs) em .NET, Python e Java. Ele simplifica o processo de uso de chamadas de função, descrevendo automaticamente suas funções e seus parâmetros para o modelo por meio de um processo chamado [serialização](https://learn.microsoft.com/semantic-kernel/concepts/ai-services/chat-completion/function-calling/?pivots=programming-language-python#1-serializing-the-functions). Ele também gerencia a comunicação entre o modelo e seu código. Outra vantagem de usar um framework agentivo como o Semantic Kernel é que ele permite acessar ferramentas pré-configuradas, como [Busca de Arquivos](https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/openai_assistant/step4_assistant_tool_file_search.py) e [Interpretador de Código](https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/openai_assistant/step3_assistant_tool_code_interpreter.py).

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

    ![function calling](../../../translated_images/functioncalling-diagram.b5493ea5154ad8e3e4940d2e36a49101eec1398948e5d1039942203b4f5a4209.pt.png)

    No Semantic Kernel, funções/ferramentas são chamadas de [Plugins](https://learn.microsoft.com/semantic-kernel/concepts/plugins/?pivots=programming-language-python). Podemos converter o `get_current_time` function we saw earlier into a plugin by turning it into a class with the function in it. We can also import the `kernel_function` decorator, que recebe a descrição da função. Quando você cria um kernel com o GetCurrentTimePlugin, o kernel automaticamente serializa a função e seus parâmetros, criando o esquema a ser enviado ao LLM no processo.

    ```python
    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 = ""):
            ...

    ```

    ```python
    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](https://learn.microsoft.com/azure/ai-services/agents/overview)**

    O Azure AI Agent Service é um framework agentivo mais recente, projetado para capacitar desenvolvedores a criar, implantar e escalar agentes de IA de alta qualidade e extensíveis de forma segura, sem a necessidade de gerenciar recursos de computação e armazenamento subjacentes. Ele é particularmente útil para aplicações empresariais, pois é um serviço totalmente gerenciado com segurança de nível corporativo.

    Quando comparado ao desenvolvimento diretamente com a API LLM, o Azure AI Agent Service oferece algumas vantagens, incluindo:
  - Chamadas de ferramenta automáticas – não é necessário analisar uma chamada de ferramenta, invocar a ferramenta e lidar com a resposta; tudo isso agora é feito no lado do servidor.
  - Gerenciamento seguro de dados – em vez de gerenciar seu próprio estado de conversação, você pode contar com threads para armazenar todas as informações necessárias.
  - Ferramentas prontas para uso – Ferramentas que você pode usar para interagir com suas 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:
        - [Grounding com Bing Search](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/bing-grounding?tabs=python&pivots=overview)
        - [Busca de Arquivos](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/file-search?tabs=python&pivots=overview)
        - [Azure AI Search](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/azure-ai-search?tabs=azurecli%2Cpython&pivots=overview-azure-ai-search)

    2. Ferramentas de Ação:
        - [Chamada de Função](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/function-calling?tabs=python&pivots=overview)
        - [Interpretador de Código](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/code-interpreter?tabs=python&pivots=overview)
        - [Ferramentas definidas pelo OpenAI](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/openapi-spec?tabs=python&pivots=overview)
        - [Azure Functions](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/azure-functions?pivots=overview)

    O Agent Service nos permite usar essas ferramentas juntas como um `toolset`. It also utilizes `threads` which keep track of the history of messages from a particular conversation.

    Imagine you are a sales agent at a company called Contoso. You want to develop a conversational agent that can answer questions about your sales data.

    The image below illustrates how you could use Azure AI Agent Service to analyze your sales data:

    ![Agentic Service In Action](../../../translated_images/agent-service-in-action.8c2d8aa8e9d91feeb29549b3fde529f8332b243875154d03907616a69198afbc.de.jpg?WT.mc_id=academic-105485-koreyst)

    To use any of these tools with the service we can create a client and define a tool or toolset. To implement this practically we can use the Python code below. The LLM will be able to look at the toolset and decide whether to use the user created function, `fetch_sales_data_using_sqlite_query`, ou o Interpretador de Código pré-configurado dependendo da solicitação do usuário.

    ```python
    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 fecth_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 as considerações especiais ao usar o Padrão de Design para Uso de Ferramentas para criar agentes de IA confiáveis?

Uma preocupação comum com SQL gerado dinamicamente por LLMs é a segurança, particularmente o risco de injeção de SQL ou ações maliciosas, como excluir ou alterar o banco de dados. Embora essas preocupações sejam válidas, elas podem ser mitigadas de forma eficaz configurando corretamente as permissões de acesso ao banco de dados. Para a maioria dos bancos de dados, isso envolve configurá-los como somente leitura. Para serviços de banco de dados como PostgreSQL ou Azure SQL, o aplicativo deve receber uma função de somente leitura (SELECT).

Executar o aplicativo em um ambiente seguro aumenta ainda mais a proteção. Em cenários empresariais, os dados geralmente são extraídos e transformados de sistemas operacionais para um banco de dados somente leitura ou data warehouse com um esquema amigável ao usuário. Essa abordagem garante que os dados sejam seguros, otimizados para desempenho e acessibilidade, e que o aplicativo tenha acesso restrito e somente leitura.

## Recursos Adicionais

- [Workshop do Azure AI Agents Service](https://microsoft.github.io/build-your-first-agent-with-azure-ai-agent-service-workshop/)
- [Workshop Multi-Agente do Contoso Creative Writer](https://github.com/Azure-Samples/contoso-creative-writer/tree/main/docs/workshop)
- [Tutorial de Chamadas de Função do Semantic Kernel](https://learn.microsoft.com/semantic-kernel/concepts/ai-services/chat-completion/function-calling/?pivots=programming-language-python#1-serializing-the-functions)
- [Interpretador de Código do Semantic Kernel](https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/openai_assistant/step3_assistant_tool_code_interpreter.py)
- [Ferramentas Autogen](https://microsoft.github.io/autogen/dev/user-guide/core-user-guide/components/tools.html)
```

**Aviso Legal**:
Este documento foi traduzido usando serviços de tradução baseados em IA. Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.

10 Lessons to Get Started Building AI Agents


# Agentic RAG

Esta lição oferece uma visão abrangente do Agentic Retrieval-Augmented Generation (Agentic RAG), um paradigma emergente de IA onde grandes modelos de linguagem (LLMs) planejam autonomamente seus próximos passos enquanto buscam informações de fontes externas. Diferente dos padrões estáticos de "recuperar e depois ler", o Agentic RAG envolve chamadas iterativas ao LLM, intercaladas com chamadas de ferramentas ou funções e saídas estruturadas. O sistema avalia os resultados, refina consultas, invoca ferramentas adicionais se necessário e continua esse ciclo até alcançar uma solução satisfatória.

## Introdução

Esta lição abordará:

- **Entender o Agentic RAG:** Conheça o paradigma emergente em IA onde grandes modelos de linguagem (LLMs) planejam autonomamente seus próximos passos enquanto buscam informações de fontes externas.
- **Compreender o Estilo Iterativo Maker-Checker:** Entenda o ciclo de chamadas iterativas ao LLM, intercaladas com chamadas de ferramentas ou funções e saídas estruturadas, projetado para melhorar a precisão e lidar com consultas malformadas.
- **Explorar Aplicações Práticas:** Identifique cenários onde o Agentic RAG se destaca, como ambientes onde a precisão é prioritária, interações complexas com bancos de dados e fluxos de trabalho prolongados.

## Objetivos de Aprendizado

Após concluir esta lição, você será capaz de:

- **Compreender o Agentic RAG:** Conhecer o paradigma emergente em IA onde grandes modelos de linguagem (LLMs) planejam autonomamente seus próximos passos enquanto buscam informações de fontes externas.
- **Estilo Iterativo Maker-Checker:** Assimilar o conceito de um ciclo de chamadas iterativas ao LLM, intercaladas com chamadas de ferramentas ou funções e saídas estruturadas, projetado para melhorar a precisão e lidar com consultas malformadas.
- **Assumir o Processo de Raciocínio:** Entender a capacidade do sistema de assumir seu processo de raciocínio, tomando decisões sobre como abordar problemas sem depender de caminhos predefinidos.
- **Fluxo de Trabalho:** Compreender como um modelo agentic decide independentemente recuperar relatórios de tendências de mercado, identificar dados de concorrentes, correlacionar métricas internas de vendas, sintetizar conclusões e avaliar a estratégia.
- **Loops Iterativos, Integração de Ferramentas e Memória:** Aprender sobre a dependência do sistema em um padrão de interação em loop, mantendo estado e memória entre etapas para evitar loops repetitivos e tomar decisões informadas.
- **Lidar com Modos de Falha e Auto-Correção:** Explorar os mecanismos robustos de auto-correção do sistema, incluindo iteração e reconsultas, uso de ferramentas de diagnóstico e recurso à supervisão humana.
- **Limites da Agência:** Entender as limitações do Agentic RAG, focando na autonomia específica do domínio, dependência de infraestrutura e respeito a limites de segurança.
- **Casos de Uso Práticos e Valor:** Identificar cenários onde o Agentic RAG se destaca, como ambientes de alta precisão, interações complexas com bancos de dados e fluxos de trabalho prolongados.
- **Governança, Transparência e Confiança:** Aprender sobre a importância da governança e transparência, incluindo raciocínio explicável, controle de vieses e supervisão humana.

## O que é Agentic RAG?

Agentic Retrieval-Augmented Generation (Agentic RAG) é um paradigma emergente de IA onde grandes modelos de linguagem (LLMs) planejam autonomamente seus próximos passos enquanto buscam informações de fontes externas. Diferente dos padrões estáticos de "recuperar e depois ler", o Agentic RAG envolve chamadas iterativas ao LLM, intercaladas com chamadas de ferramentas ou funções e saídas estruturadas. O sistema avalia resultados, refina consultas, invoca ferramentas adicionais se necessário e continua esse ciclo até alcançar uma solução satisfatória. Este estilo iterativo “maker-checker” melhora a precisão, lida com consultas malformadas e garante resultados de alta qualidade.

O sistema assume ativamente seu processo de raciocínio, reescrevendo consultas falhas, escolhendo diferentes métodos de recuperação e integrando várias ferramentas—como busca vetorial no Azure AI Search, bancos de dados SQL ou APIs personalizadas—antes de finalizar sua resposta. A qualidade distintiva de um sistema agentic é sua capacidade de assumir o processo de raciocínio. Implementações tradicionais de RAG dependem de caminhos predefinidos, mas um sistema agentic determina autonomamente a sequência de passos com base na qualidade da informação encontrada.

## Definindo Agentic Retrieval-Augmented Generation (Agentic RAG)

Agentic Retrieval-Augmented Generation (Agentic RAG) é um paradigma emergente no desenvolvimento de IA onde LLMs não apenas buscam informações de fontes externas de dados, mas também planejam autonomamente seus próximos passos. Diferente dos padrões estáticos de "recuperar e depois ler" ou sequências de prompts cuidadosamente roteirizadas, o Agentic RAG envolve um ciclo de chamadas iterativas ao LLM, intercaladas com chamadas de ferramentas ou funções e saídas estruturadas. A cada etapa, o sistema avalia os resultados obtidos, decide se deve refinar suas consultas, invoca ferramentas adicionais se necessário e continua esse ciclo até alcançar uma solução satisfatória.

Este estilo iterativo “maker-checker” foi projetado para melhorar a precisão, lidar com consultas malformadas para bancos de dados estruturados (ex.: NL2SQL) e garantir resultados equilibrados e de alta qualidade. Em vez de depender exclusivamente de cadeias de prompts cuidadosamente elaboradas, o sistema assume ativamente seu processo de raciocínio. Ele pode reescrever consultas que falham, escolher diferentes métodos de recuperação e integrar várias ferramentas—como busca vetorial no Azure AI Search, bancos de dados SQL ou APIs personalizadas—antes de finalizar sua resposta. Isso elimina a necessidade de estruturas de orquestração excessivamente complexas. Em vez disso, um loop relativamente simples de “chamada LLM → uso de ferramenta → chamada LLM → …” pode produzir saídas sofisticadas e bem fundamentadas.

![Agentic RAG Core Loop](../../../05-agentic-rag/images/agentic-rag-core-loop.png)

## Assumindo o Processo de Raciocínio

A qualidade distintiva que torna um sistema “agentic” é sua capacidade de assumir seu processo de raciocínio. Implementações tradicionais de RAG frequentemente dependem de humanos para predefinir um caminho para o modelo: uma cadeia de raciocínio que descreve o que recuperar e quando. Mas quando um sistema é verdadeiramente agentic, ele decide internamente como abordar o problema. Não está apenas executando um script; está determinando autonomamente a sequência de passos com base na qualidade da informação que encontra.

Por exemplo, se solicitado a criar uma estratégia de lançamento de produto, ele não depende apenas de um prompt que descreva todo o fluxo de trabalho de pesquisa e tomada de decisão. Em vez disso, o modelo agentic decide independentemente:

1. Recuperar relatórios de tendências de mercado atuais usando Bing Web Grounding.
2. Identificar dados relevantes de concorrentes usando Azure AI Search.
3. Correlacionar métricas históricas internas de vendas usando Azure SQL Database.
4. Sintetizar as descobertas em uma estratégia coesa orquestrada via Azure OpenAI Service.
5. Avaliar a estratégia em busca de lacunas ou inconsistências, promovendo outra rodada de recuperação se necessário.

Todas essas etapas—refinar consultas, escolher fontes, iterar até “ficar satisfeito” com a resposta—são decididas pelo modelo, não roteirizadas previamente por um humano.

## Loops Iterativos, Integração de Ferramentas e Memória

![Tool Integration Architecture](../../../05-agentic-rag/images/tool-integration.png)

Um sistema agentic depende de um padrão de interação em loop:

- **Chamada Inicial:** O objetivo do usuário (também conhecido como prompt do usuário) é apresentado ao LLM.
- **Invocação de Ferramenta:** Se o modelo identificar informações ausentes ou instruções ambíguas, ele seleciona uma ferramenta ou método de recuperação—como uma consulta a um banco de dados vetorial (ex.: Azure AI Search Hybrid search sobre dados privados) ou uma chamada SQL estruturada—para obter mais contexto.
- **Avaliação e Refinamento:** Após revisar os dados retornados, o modelo decide se a informação é suficiente. Caso contrário, refina a consulta, tenta uma ferramenta diferente ou ajusta sua abordagem.
- **Repetir Até Satisfação:** Este ciclo continua até que o modelo determine que tem clareza e evidências suficientes para entregar uma resposta final bem fundamentada.
- **Memória e Estado:** Como o sistema mantém estado e memória entre etapas, ele pode lembrar tentativas anteriores e seus resultados, evitando loops repetitivos e tomando decisões mais informadas à medida que avança.

Com o tempo, isso cria um senso de entendimento evolutivo, permitindo que o modelo navegue por tarefas complexas e em várias etapas sem exigir que um humano intervenha constantemente ou reformule o prompt.

## Lidando com Modos de Falha e Auto-Correção

A autonomia do Agentic RAG também envolve mecanismos robustos de auto-correção. Quando o sistema encontra impasses—como recuperação de documentos irrelevantes ou consultas malformadas—ele pode:

- **Iterar e Reconsultar:** Em vez de retornar respostas de baixo valor, o modelo tenta novas estratégias de busca, reescreve consultas a bancos de dados ou examina conjuntos de dados alternativos.
- **Usar Ferramentas de Diagnóstico:** O sistema pode invocar funções adicionais projetadas para ajudá-lo a depurar seus passos de raciocínio ou confirmar a precisão dos dados recuperados. Ferramentas como Azure AI Tracing serão importantes para possibilitar observabilidade e monitoramento robustos.
- **Recorrer à Supervisão Humana:** Para cenários críticos ou falhas recorrentes, o modelo pode sinalizar incertezas e solicitar orientação humana. Uma vez que o humano forneça feedback corretivo, o modelo pode incorporar essa lição para seguir em frente.

Essa abordagem iterativa e dinâmica permite que o modelo melhore continuamente, garantindo que ele não seja apenas um sistema de tentativa única, mas sim um que aprende com seus erros durante uma sessão específica.

![Self Correction Mechanism](../../../05-agentic-rag/images/self-correction.png)

## Limites da Agência

Apesar de sua autonomia dentro de uma tarefa, o Agentic RAG não é equivalente à Inteligência Artificial Geral. Suas capacidades “agentic” estão confinadas às ferramentas, fontes de dados e políticas fornecidas pelos desenvolvedores humanos. Ele não pode inventar suas próprias ferramentas ou ultrapassar os limites do domínio que foram estabelecidos. Em vez disso, destaca-se ao orquestrar dinamicamente os recursos disponíveis.

Diferenças importantes em relação a formas mais avançadas de IA incluem:

1. **Autonomia Específica do Domínio:** Sistemas Agentic RAG são focados em alcançar objetivos definidos pelo usuário dentro de um domínio conhecido, empregando estratégias como reescrita de consultas ou seleção de ferramentas para melhorar os resultados.
2. **Dependência de Infraestrutura:** As capacidades do sistema dependem das ferramentas e dados integrados pelos desenvolvedores. Ele não pode ultrapassar esses limites sem intervenção humana.
3. **Respeito aos Limites:** Diretrizes éticas, regras de conformidade e políticas empresariais permanecem muito importantes. A liberdade do agente é sempre limitada por medidas de segurança e mecanismos de supervisão (esperançosamente?).

## Casos de Uso Práticos e Valor

O Agentic RAG se destaca em cenários que exigem refinamento iterativo e precisão:

1. **Ambientes de Alta Precisão:** Em verificações de conformidade, análises regulatórias ou pesquisas jurídicas, o modelo agentic pode verificar repetidamente fatos, consultar múltiplas fontes e reescrever consultas até produzir uma resposta minuciosamente validada.

2. **Interações Complexas com Bancos de Dados:** Ao lidar com dados estruturados, onde consultas frequentemente falham ou precisam de ajustes, o sistema pode refinar autonomamente suas consultas usando Azure SQL ou Microsoft Fabric OneLake, garantindo que a recuperação final esteja alinhada com a intenção do usuário.

3. **Fluxos de Trabalho Prolongados:** Sessões mais longas podem evoluir à medida que novas informações surgem. O Agentic RAG pode incorporar continuamente novos dados, ajustando estratégias conforme aprende mais sobre o problema.

## Governança, Transparência e Confiança

À medida que esses sistemas se tornam mais autônomos em seu raciocínio, a governança e a transparência são cruciais:

- **Raciocínio Explicável:** O modelo pode fornecer um registro auditável das consultas feitas, das fontes consultadas e dos passos de raciocínio seguidos para chegar à conclusão. Ferramentas como Azure AI Content Safety e Azure AI Tracing / GenAIOps podem ajudar a manter a transparência e mitigar riscos.
- **Controle de Viés e Recuperação Balanceada:** Desenvolvedores podem ajustar estratégias de recuperação para garantir que fontes de dados equilibradas e representativas sejam consideradas, auditando regularmente as saídas para detectar vieses ou padrões enviesados usando modelos personalizados para organizações avançadas de ciência de dados com Azure Machine Learning.
- **Supervisão Humana e Conformidade:** Para tarefas sensíveis, a revisão humana continua sendo essencial. O Agentic RAG não substitui o julgamento humano em decisões críticas—ele o complementa ao oferecer opções mais minuciosamente validadas.

Ter ferramentas que forneçam um registro claro das ações é essencial. Sem elas, depurar um processo em várias etapas pode ser muito difícil. Veja abaixo um exemplo da Literal AI (empresa por trás do Chainlit) para uma execução de agente:

![AgentRunExample](../../../05-agentic-rag/images/AgentRunExample.png)

![AgentRunExample2](../../../05-agentic-rag/images/AgentRunExample2.png)

## Conclusão

O Agentic RAG representa uma evolução natural na forma como sistemas de IA lidam com tarefas complexas e intensivas em dados. Ao adotar um padrão de interação em loop, selecionar ferramentas autonomamente e refinar consultas até alcançar um resultado de alta qualidade, o sistema vai além do simples seguimento de prompts estáticos, tornando-se um tomador de decisões mais adaptável e consciente do contexto. Embora ainda limitado por infraestruturas definidas por humanos e diretrizes éticas, essas capacidades agentic permitem interações de IA mais ricas, dinâmicas e, em última análise, mais úteis para empresas e usuários finais.

## Recursos Adicionais

- Implementar Retrieval Augmented Generation (RAG) com Azure OpenAI Service: Saiba como usar seus próprios dados com o Azure OpenAI Service. [Este módulo do Microsoft Learn oferece um guia abrangente sobre como implementar RAG](https://learn.microsoft.com/training/modules/use-own-data-azure-openai)
- Avaliação de aplicativos de IA generativa com Azure AI Foundry: Este artigo aborda a avaliação e comparação de modelos em conjuntos de dados públicos, incluindo [aplicativos de IA agentic e arquiteturas RAG](https://learn.microsoft.com/azure/ai-studio/concepts/evaluation-approach-gen-ai)
- [What is Agentic RAG | Weaviate](https://weaviate.io/blog/what-is-agentic-rag)
- [Agentic RAG: A Complete Guide to Agent-Based Retrieval Augmented Generation – News from generation RAG](https://ragaboutit.com/agentic-rag-a-complete-guide-to-agent-based-retrieval-augmented-generation/)
- [Agentic RAG: turbocharge your RAG with query reformulation and self-query! Hugging Face Open-Source AI Cookbook](https://huggingface.co/learn/cookbook/agent_rag)
- [Adding Agentic Layers to RAG](https://youtu.be/aQ4yQXeB1Ss?si=2HUqBzHoeB5tR04U)
- [The Future of Knowledge Assistants: Jerry Liu](https://www.youtube.com/watch?v=zeAyuLc_f3Q&t=244s)
- [How to Build Agentic RAG Systems](https://www.youtube.com/watch?v=AOSjiXP1jmQ)
- [Using Azure AI Foundry Agent Service to scale your AI agents](https://ignite.microsoft.com/sessions/BRK102?source=sessions)

### Artigos Acadêmicos

- [2303.17651 Self-Refine: Iterative Refinement with Self-Feedback](https://arxiv.org/abs/2303.17651)
- [2303.11366 Reflexion: Language Agents with Verbal Reinforcement Learning](https://arxiv.org/abs/2303.11366)
- [2305.11738 CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing](https://arxiv.org/abs/2305.11738)
```

**Aviso Legal**:
Este documento foi traduzido utilizando serviços de tradução baseados em IA. Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte oficial. Para informações críticas, recomenda-se uma tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.


# Construindo Agentes de IA Confiáveis

## Introdução

Esta lição abordará:

- Como construir e implementar agentes de IA seguros e eficazes.
- Considerações importantes de segurança ao desenvolver agentes de IA.
- Como manter a privacidade de dados e usuários ao desenvolver agentes de IA.

## Objetivos de Aprendizagem

Após concluir esta lição, você saberá como:

- Identificar e mitigar riscos ao criar agentes de IA.
- Implementar medidas de segurança para garantir que os dados e acessos sejam gerenciados corretamente.
- Criar agentes de IA que mantenham a privacidade de dados e proporcionem uma experiência de qualidade ao usuário.

## Segurança

Vamos começar analisando como construir aplicações agentivas seguras. Segurança significa que o agente de IA atua conforme projetado. Como criadores de aplicações agentivas, temos métodos e ferramentas para maximizar a segurança:

### Construindo um Sistema de Meta Prompting

Se você já criou uma aplicação de IA usando Modelos de Linguagem de Grande Escala (LLMs), sabe da importância de projetar um prompt ou mensagem de sistema robusta. Esses prompts estabelecem as regras, instruções e diretrizes gerais para como o LLM interagirá com o usuário e os dados.

Para agentes de IA, o prompt do sistema é ainda mais importante, pois os agentes precisarão de instruções altamente específicas para realizar as tarefas que projetamos para eles.

Para criar prompts de sistema escaláveis, podemos usar um sistema de meta prompting para construir um ou mais agentes em nossa aplicação:

![Construindo um Sistema de Meta Prompting](../../../translated_images/building-a-metaprompting-system.aa7d6de2100b0ef48c3e1926dab6903026b22fc9d27fc4327162fbbb9caf960f.pt.png)

#### Etapa 1: Criar um Meta Prompt ou Prompt Modelo

O meta prompt será usado por um LLM para gerar os prompts de sistema para os agentes que criarmos. Projetamos isso como um modelo para que possamos criar múltiplos agentes de maneira eficiente, se necessário.

Aqui está um exemplo de um meta prompt que forneceríamos ao LLM:

```plaintext
You are an expert at creating AI agent assitants.
You will be provided a company name, role, responsibilites and other
information that you will use to provide a system prompt for.
To create the system prompt, be descriptive as possible and provide a structure that a system using an LLM can better understand the role and responsibilites of the AI assistant.
```

#### Etapa 2: Criar um Prompt Básico

A próxima etapa é criar um prompt básico para descrever o agente de IA. Você deve incluir o papel do agente, as tarefas que ele realizará e quaisquer outras responsabilidades atribuídas ao agente.

Aqui está um exemplo:

```plaintext
You are a travel agent for Contoso Travel with that is great at booking flights for customers. To help customers you can perform the following tasks: lookup available flights, book flights, ask for preferences in seating and times for flights, cancel any previously booked flights and alert customers on any delays or cancellations of flights.
```

#### Etapa 3: Fornecer o Prompt Básico ao LLM

Agora podemos otimizar este prompt fornecendo o meta prompt como o prompt de sistema e nosso prompt básico.

Isso produzirá um prompt melhor projetado para guiar nossos agentes de IA:

```markdown
**Company Name:** Contoso Travel
**Role:** Travel Agent Assistant

**Objective:**
You are an AI-powered travel agent assistant for Contoso Travel, specializing in booking flights and providing exceptional customer service. Your main goal is to assist customers in finding, booking, and managing their flights, all while ensuring that their preferences and needs are met efficiently.

**Key Responsibilities:**

1. **Flight Lookup:**

    - Assist customers in searching for available flights based on their specified destination, dates, and any other relevant preferences.
    - Provide a list of options, including flight times, airlines, layovers, and pricing.
2. **Flight Booking:**

    - Facilitate the booking of flights for customers, ensuring that all details are correctly entered into the system.
    - Confirm bookings and provide customers with their itinerary, including confirmation numbers and any other pertinent information.
3. **Customer Preference Inquiry:**

    - Actively ask customers for their preferences regarding seating (e.g., aisle, window, extra legroom) and preferred times for flights (e.g., morning, afternoon, evening).
    - Record these preferences for future reference and tailor suggestions accordingly.
4. **Flight Cancellation:**

    - Assist customers in canceling previously booked flights if needed, following company policies and procedures.
    - Notify customers of any necessary refunds or additional steps that may be required for cancellations.
5. **Flight Monitoring:**

    - Monitor the status of booked flights and alert customers in real-time about any delays, cancellations, or changes to their flight schedule.
    - Provide updates through preferred communication channels (e.g., email, SMS) as needed.

**Tone and Style:**

- Maintain a friendly, professional, and approachable demeanor in all interactions with customers.
- Ensure that all communication is clear, informative, and tailored to the customer's specific needs and inquiries.

**User Interaction Instructions:**

- Respond to customer queries promptly and accurately.
- Use a conversational style while ensuring professionalism.
- Prioritize customer satisfaction by being attentive, empathetic, and proactive in all assistance provided.

**Additional Notes:**

- Stay updated on any changes to airline policies, travel restrictions, and other relevant information that could impact flight bookings and customer experience.
- Use clear and concise language to explain options and processes, avoiding jargon where possible for better customer understanding.

This AI assistant is designed to streamline the flight booking process for customers of Contoso Travel, ensuring that all their travel needs are met efficiently and effectively.

```

#### Etapa 4: Iterar e Melhorar

O valor desse sistema de meta prompting é poder escalar a criação de prompts para múltiplos agentes de forma mais fácil, além de melhorar seus prompts ao longo do tempo. É raro que você tenha um prompt que funcione perfeitamente na primeira tentativa para todo o seu caso de uso. Ser capaz de fazer pequenos ajustes e melhorias alterando o prompt básico e executando-o no sistema permitirá que você compare e avalie os resultados.

## Entendendo as Ameaças

Para construir agentes de IA confiáveis, é importante entender e mitigar os riscos e ameaças aos seus agentes de IA. Vamos analisar algumas das diferentes ameaças aos agentes de IA e como você pode planejar e se preparar melhor para elas.

![Entendendo as Ameaças](../../../translated_images/understanding-threats.f8fbe6fe11e025b3085fc91e82d975937ad1d672260a2aeed40458aa41798d0e.pt.png)

### Tarefa e Instrução

**Descrição:** Atacantes tentam alterar as instruções ou objetivos do agente de IA por meio de prompts ou manipulação de entradas.

**Mitigação:** Execute verificações de validação e filtros de entrada para detectar prompts potencialmente perigosos antes que sejam processados pelo agente de IA. Como esses ataques geralmente requerem interação frequente com o agente, limitar o número de interações em uma conversa é outra maneira de prevenir esses tipos de ataques.

### Acesso a Sistemas Críticos

**Descrição:** Se um agente de IA tem acesso a sistemas e serviços que armazenam dados sensíveis, atacantes podem comprometer a comunicação entre o agente e esses serviços. Esses ataques podem ser diretos ou tentativas indiretas de obter informações sobre esses sistemas por meio do agente.

**Mitigação:** Agentes de IA devem ter acesso a sistemas apenas quando absolutamente necessário para evitar esses tipos de ataques. A comunicação entre o agente e o sistema também deve ser segura. Implementar autenticação e controle de acesso é outra maneira de proteger essas informações.

### Sobrecarga de Recursos e Serviços

**Descrição:** Agentes de IA podem acessar diferentes ferramentas e serviços para concluir tarefas. Atacantes podem usar essa habilidade para atacar esses serviços enviando um grande volume de solicitações por meio do agente de IA, o que pode resultar em falhas no sistema ou altos custos.

**Mitigação:** Implemente políticas para limitar o número de solicitações que um agente de IA pode fazer a um serviço. Limitar o número de interações e solicitações ao seu agente de IA também é uma maneira de prevenir esses tipos de ataques.

### Envenenamento da Base de Conhecimento

**Descrição:** Esse tipo de ataque não visa diretamente o agente de IA, mas sim a base de conhecimento e outros serviços que o agente utilizará. Isso pode envolver a corrupção dos dados ou informações que o agente usará para concluir uma tarefa, levando a respostas tendenciosas ou não intencionais ao usuário.

**Mitigação:** Realize verificações regulares dos dados que o agente de IA usará em seus fluxos de trabalho. Certifique-se de que o acesso a esses dados seja seguro e que apenas pessoas confiáveis possam alterá-los para evitar esse tipo de ataque.

### Erros em Cascata

**Descrição:** Agentes de IA acessam várias ferramentas e serviços para concluir tarefas. Erros causados por atacantes podem levar a falhas em outros sistemas aos quais o agente de IA está conectado, tornando o ataque mais disseminado e difícil de solucionar.

**Mitigação:** Uma maneira de evitar isso é fazer com que o agente de IA opere em um ambiente limitado, como executar tarefas em um contêiner Docker, para evitar ataques diretos ao sistema. Criar mecanismos de fallback e lógica de repetição quando certos sistemas respondem com erro é outra maneira de evitar falhas maiores no sistema.

## Humano no Ciclo

Outra maneira eficaz de construir sistemas de agentes de IA confiáveis é usar um Humano no Ciclo. Isso cria um fluxo onde os usuários podem fornecer feedback aos agentes durante a execução. Os usuários essencialmente atuam como agentes em um sistema multiagente, fornecendo aprovação ou encerrando o processo em execução.

![Humano no Ciclo](../../../translated_images/human-in-the-loop.e9edbe8f6d42041b4213421410823250aa750fe8bdba5601d69ed46f3ff6489d.pt.png)

Aqui está um trecho de código usando AutoGen para mostrar como esse conceito é implementado:

```python

# Create the agents.
model_client = OpenAIChatCompletionClient(model="gpt-4o-mini")
assistant = AssistantAgent("assistant", model_client=model_client)
user_proxy = UserProxyAgent("user_proxy", input_func=input)  # Use input() to get user input from console.

# Create the termination condition which will end the conversation when the user says "APPROVE".
termination = TextMentionTermination("APPROVE")

# Create the team.
team = RoundRobinGroupChat([assistant, user_proxy], termination_condition=termination)

# Run the conversation and stream to the console.
stream = team.run_stream(task="Write a 4-line poem about the ocean.")
# Use asyncio.run(...) when running in a script.
await Console(stream)

```

**Aviso Legal**:
Este documento foi traduzido usando serviços de tradução automática baseados em IA. Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte oficial. Para informações críticas, recomenda-se a tradução humana profissional. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.


# Planejamento de Design

## Introdução

Esta lição abordará:

* Definir um objetivo geral claro e dividir uma tarefa complexa em tarefas gerenciáveis.
* Aproveitar saídas estruturadas para respostas mais confiáveis e legíveis por máquinas.
* Aplicar uma abordagem orientada a eventos para lidar com tarefas dinâmicas e entradas inesperadas.

## Objetivos de Aprendizagem

Após concluir esta lição, você terá um entendimento sobre:

* Identificar e estabelecer um objetivo geral para um agente de IA, garantindo que ele saiba claramente o que precisa ser alcançado.
* Dividir uma tarefa complexa em subtarefas gerenciáveis e organizá-las em uma sequência lógica.
* Equipar agentes com as ferramentas certas (por exemplo, ferramentas de busca ou de análise de dados), decidir quando e como usá-las e lidar com situações inesperadas que surgirem.
* Avaliar os resultados das subtarefas, medir o desempenho e iterar nas ações para melhorar o resultado final.

## Definindo o Objetivo Geral e Dividindo uma Tarefa

![Definindo Objetivos e Tarefas](../../../translated_images/defining-goals-tasks.dcc1181bbdb194704ae0fb3363371562949e8b03fd2fadc256218aaadf84a9f4.pt.png)

A maioria das tarefas do mundo real é muito complexa para ser resolvida em um único passo. Um agente de IA precisa de um objetivo conciso para guiar seu planejamento e ações. Por exemplo, considere o objetivo:

    "Gerar um roteiro de viagem de 3 dias."

Embora seja simples de enunciar, ainda precisa de refinamento. Quanto mais claro for o objetivo, melhor o agente (e quaisquer colaboradores humanos) poderá se concentrar em alcançar o resultado certo, como criar um roteiro abrangente com opções de voos, recomendações de hotéis e sugestões de atividades.

### Decomposição de Tarefas

Tarefas grandes ou complexas tornam-se mais gerenciáveis quando divididas em subtarefas menores e orientadas a objetivos.
No exemplo do roteiro de viagem, você poderia decompor o objetivo em:

* Reserva de Voos
* Reserva de Hotéis
* Aluguel de Carro
* Personalização

Cada subtarefa pode ser abordada por agentes ou processos dedicados. Um agente pode se especializar em buscar as melhores ofertas de voos, outro pode focar nas reservas de hotéis, e assim por diante. Um agente coordenador ou "downstream" pode então compilar esses resultados em um roteiro coeso para o usuário final.

Essa abordagem modular também permite melhorias incrementais. Por exemplo, você poderia adicionar agentes especializados em Recomendações de Restaurantes ou Sugestões de Atividades Locais, refinando o roteiro ao longo do tempo.

### Saída Estruturada

Modelos de Linguagem Extensa (LLMs) podem gerar saídas estruturadas (por exemplo, JSON) que são mais fáceis de serem interpretadas e processadas por agentes ou serviços subsequentes. Isso é especialmente útil em um contexto multiagente, onde podemos executar essas tarefas após receber a saída do planejamento. Consulte este [blogpost](https://microsoft.github.io/autogen/stable/user-guide/core-user-guide/cookbook/structured-output-agent.html) para uma visão geral rápida.

Abaixo está um exemplo de trecho de código Python que demonstra um agente de planejamento simples decompondo um objetivo em subtarefas e gerando um plano estruturado:

### Agente de Planejamento com Orquestração Multiagente

Neste exemplo, um Agente de Roteamento Semântico recebe uma solicitação do usuário (por exemplo, "Eu preciso de um plano de hotel para minha viagem.").

O planejador então:

* Recebe o Plano de Hotel: O planejador recebe a mensagem do usuário e, com base em um prompt do sistema (incluindo detalhes dos agentes disponíveis), gera um plano de viagem estruturado.
* Lista os Agentes e Suas Ferramentas: O registro de agentes mantém uma lista de agentes (por exemplo, para voos, hotéis, aluguel de carros e atividades) juntamente com as funções ou ferramentas que eles oferecem.
* Encaminha o Plano para os Agentes Respectivos: Dependendo do número de subtarefas, o planejador envia a mensagem diretamente para um agente dedicado (para cenários de tarefa única) ou coordena via um gerenciador de chat em grupo para colaboração multiagente.
* Resume o Resultado: Finalmente, o planejador resume o plano gerado para maior clareza.
Abaixo está o exemplo de código Python ilustrando essas etapas:

```python

from pydantic import BaseModel

from enum import Enum
from typing import List, Optional, Union

class AgentEnum(str, Enum):
    FlightBooking = "flight_booking"
    HotelBooking = "hotel_booking"
    CarRental = "car_rental"
    ActivitiesBooking = "activities_booking"
    DestinationInfo = "destination_info"
    DefaultAgent = "default_agent"
    GroupChatManager = "group_chat_manager"

# Travel SubTask Model

class TravelSubTask(BaseModel):
    task_details: str
    assigned_agent: AgentEnum # we want to assign the task to the agent

class TravelPlan(BaseModel):
    main_task: str
    subtasks: List[TravelSubTask]
    is_greeting: bool
import json
import os
from typing import Optional

from autogen_core.models import UserMessage, SystemMessage, AssistantMessage
from autogen_ext.models.openai import AzureOpenAIChatCompletionClient

# Create the client with type-checked environment variables

client = AzureOpenAIChatCompletionClient(
    azure_deployment=os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME"),
    model=os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME"),
    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
)

from pprint import pprint

# Define the user message

messages = [
    SystemMessage(content="""You are an planner agent.
    Your job is to decide which agents to run based on the user's request.
    Below are the available agents specialised in different tasks:
    - FlightBooking: For booking flights and providing flight information
    - HotelBooking: For booking hotels and providing hotel information
    - CarRental: For booking cars and providing car rental information
    - ActivitiesBooking: For booking activities and providing activity information
    - DestinationInfo: For providing information about destinations
    - DefaultAgent: For handling general requests""", source="system"),
    UserMessage(content="Create a travel plan for a family of 2 kids from Singapore to Melbourne", source="user"),
]

response = await client.create(messages=messages, extra_create_args={"response_format": TravelPlan})

# Ensure the response content is a valid JSON string before loading it

response_content: Optional[str] = response.content if isinstance(response.content, str) else None
if response_content is None:
    raise ValueError("Response content is not a valid JSON string")

# Print the response content after loading it as JSON

pprint(json.loads(response_content))
```

Abaixo está a saída do código acima, e você pode usar essa saída estruturada para encaminhar para `assigned_agent` e resumir o plano de viagem para o usuário final:

```json
{
    "is_greeting": "False",
    "main_task": "Plan a family trip from Singapore to Melbourne.",
    "subtasks": [
        {
            "assigned_agent": "flight_booking",
            "task_details": "Book round-trip flights from Singapore to Melbourne."
        },
        {
            "assigned_agent": "hotel_booking",
            "task_details": "Find family-friendly hotels in Melbourne."
        },
        {
            "assigned_agent": "car_rental",
            "task_details": "Arrange a car rental suitable for a family of four in Melbourne."
        },
        {
            "assigned_agent": "activities_booking",
            "task_details": "List family-friendly activities in Melbourne."
        },
        {
            "assigned_agent": "destination_info",
            "task_details": "Provide information about Melbourne as a travel destination."
        }
    ]
}
```

Um notebook de exemplo com o código acima está disponível [aqui](../../../07-planning-design/code_samples/07-autogen.ipynb).

### Planejamento Iterativo

Algumas tarefas requerem um processo de ida e volta ou replanejamento, onde o resultado de uma subtarefa influencia a próxima. Por exemplo, se o agente encontrar um formato de dados inesperado ao reservar voos, ele pode precisar adaptar sua estratégia antes de prosseguir com as reservas de hotéis.

Além disso, o feedback do usuário (por exemplo, um humano decidindo que prefere um voo mais cedo) pode desencadear um replanejamento parcial. Essa abordagem dinâmica e iterativa garante que a solução final esteja alinhada com as restrições do mundo real e com as preferências em evolução do usuário.

Exemplo de código:

    ```python
    from autogen_core.models import UserMessage, SystemMessage, AssistantMessage
    #.. same as previous code and pass on the user history, current plan
    messages = [
        SystemMessage(content="""You are a planner agent to optimize the
        Your job is to decide which agents to run based on the user's request.
        Below are the available agents specialised in different tasks:
        - FlightBooking: For booking flights and providing flight information
        - HotelBooking: For booking hotels and providing hotel information
        - CarRental: For booking cars and providing car rental information
        - ActivitiesBooking: For booking activities and providing activity information
        - DestinationInfo: For providing information about destinations
        - DefaultAgent: For handling general requests""", source="system"),
        UserMessage(content="Create a travel plan for a family of 2 kids from Singapore to Melboune", source="user"),
        AssistantMessage(content=f"Previous travel plan - {TravelPlan}", source="assistant")
    ]
    # .. re-plan and send the tasks to respective agents
    ```

Para um planejamento mais abrangente, confira o [Blogpost Magnetic One](https://www.microsoft.com/research/articles/magentic-one-a-generalist-multi-agent-system-for-solving-complex-tasks) para resolver tarefas complexas.

## Resumo

Neste artigo, analisamos um exemplo de como criar um planejador que pode selecionar dinamicamente os agentes disponíveis definidos. A saída do Planejador decompõe as tarefas e atribui os agentes para que elas sejam executadas. Assume-se que os agentes têm acesso às funções/ferramentas necessárias para realizar a tarefa. Além dos agentes, você pode incluir outros padrões, como reflexão, sumarização e chat round robin, para personalizar ainda mais.

## Recursos Adicionais

* Usar modelos de raciocínio o1 tem se mostrado bastante avançado no planejamento de tarefas complexas - TODO: Compartilhar exemplo?

* Autogen Magnetic One - Um sistema multiagente generalista para resolver tarefas complexas que alcançou resultados impressionantes em vários benchmarks desafiadores de agentes. Referência: [autogen-magentic-one](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-magentic-one). Nesta implementação, o orquestrador cria um plano específico para a tarefa e delega essas tarefas aos agentes disponíveis. Além do planejamento, o orquestrador também emprega um mecanismo de rastreamento para monitorar o progresso da tarefa e replanejar conforme necessário.

**Aviso Legal**:
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos para alcançar precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte oficial. Para informações críticas, recomenda-se a tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.


# Padrões de Design para Multiagentes

Assim que você começar a trabalhar em um projeto que envolve múltiplos agentes, será necessário considerar o padrão de design para multiagentes. No entanto, pode não ser imediatamente claro quando mudar para um sistema multiagente e quais são as vantagens disso.

## Introdução

Nesta lição, buscamos responder às seguintes perguntas:

- Quais são os cenários onde os multiagentes são aplicáveis?
- Quais são as vantagens de usar multiagentes em vez de um único agente realizando múltiplas tarefas?
- Quais são os componentes fundamentais para implementar o padrão de design para multiagentes?
- Como podemos ter visibilidade sobre como os múltiplos agentes estão interagindo entre si?

## Objetivos de Aprendizagem

Após esta lição, você deverá ser capaz de:

- Identificar cenários onde os multiagentes são aplicáveis.
- Reconhecer as vantagens de usar multiagentes em vez de um único agente.
- Compreender os componentes fundamentais para implementar o padrão de design para multiagentes.

Qual é o panorama geral?

*Multiagentes são um padrão de design que permite que múltiplos agentes trabalhem juntos para alcançar um objetivo comum.*

Esse padrão é amplamente utilizado em diversos campos, incluindo robótica, sistemas autônomos e computação distribuída.

## Cenários Onde Multiagentes São Aplicáveis

Então, em quais cenários o uso de multiagentes é uma boa escolha? A resposta é que há muitos cenários onde empregar múltiplos agentes é benéfico, especialmente nos seguintes casos:

- **Grandes volumes de trabalho**: Tarefas extensas podem ser divididas em partes menores e atribuídas a diferentes agentes, permitindo processamento paralelo e conclusão mais rápida. Um exemplo disso é no caso de uma tarefa de processamento de dados em larga escala.
- **Tarefas complexas**: Tarefas complexas, assim como grandes volumes de trabalho, podem ser divididas em subtarefas menores e atribuídas a diferentes agentes, cada um especializado em um aspecto específico da tarefa. Um bom exemplo disso é no caso de veículos autônomos, onde diferentes agentes gerenciam navegação, detecção de obstáculos e comunicação com outros veículos.
- **Diversidade de especialização**: Diferentes agentes podem ter especializações distintas, permitindo que lidem com diferentes aspectos de uma tarefa de forma mais eficaz do que um único agente. Um bom exemplo disso é no setor de saúde, onde agentes podem gerenciar diagnósticos, planos de tratamento e monitoramento de pacientes.

## Vantagens de Usar Multiagentes em Comparação a um Único Agente

Um sistema com um único agente pode funcionar bem para tarefas simples, mas para tarefas mais complexas, usar múltiplos agentes pode oferecer várias vantagens:

- **Especialização**: Cada agente pode ser especializado para uma tarefa específica. A falta de especialização em um único agente significa que ele pode fazer de tudo, mas pode se confundir ao lidar com tarefas complexas. Ele pode, por exemplo, acabar realizando uma tarefa para a qual não é o mais adequado.
- **Escalabilidade**: É mais fácil escalar sistemas adicionando mais agentes em vez de sobrecarregar um único agente.
- **Tolerância a falhas**: Se um agente falhar, outros podem continuar funcionando, garantindo a confiabilidade do sistema.

Vamos a um exemplo: reservar uma viagem para um usuário. Um sistema com um único agente teria que lidar com todos os aspectos do processo de reserva, desde encontrar voos até reservar hotéis e carros de aluguel. Para fazer isso com um único agente, ele precisaria de ferramentas para lidar com todas essas tarefas. Isso poderia levar a um sistema complexo e monolítico, difícil de manter e escalar. Um sistema multiagente, por outro lado, poderia ter diferentes agentes especializados em encontrar voos, reservar hotéis e carros de aluguel. Isso tornaria o sistema mais modular, fácil de manter e escalável.

Compare isso a uma agência de viagens administrada como um pequeno negócio familiar versus uma agência operada como uma franquia. O negócio familiar teria um único agente lidando com todos os aspectos do processo de reserva, enquanto a franquia teria diferentes agentes responsáveis por diferentes aspectos do processo.

## Componentes Fundamentais para Implementar o Padrão de Design para Multiagentes

Antes de implementar o padrão de design para multiagentes, é necessário entender os componentes que compõem esse padrão.

Vamos tornar isso mais concreto analisando novamente o exemplo de reservar uma viagem para um usuário. Nesse caso, os componentes fundamentais incluiriam:

- **Comunicação entre agentes**: Agentes responsáveis por encontrar voos, reservar hotéis e carros de aluguel precisam se comunicar e compartilhar informações sobre as preferências e restrições do usuário. É necessário decidir os protocolos e métodos para essa comunicação. Concretamente, isso significa que o agente responsável por encontrar voos precisa se comunicar com o agente de reservas de hotéis para garantir que o hotel seja reservado para as mesmas datas do voo. Isso significa que os agentes precisam compartilhar informações sobre as datas de viagem do usuário, ou seja, você precisa decidir *quais agentes compartilham informações e como fazem isso*.
- **Mecanismos de coordenação**: Os agentes precisam coordenar suas ações para garantir que as preferências e restrições do usuário sejam atendidas. Por exemplo, uma preferência do usuário pode ser ficar em um hotel próximo ao aeroporto, enquanto uma restrição pode ser que carros de aluguel só estejam disponíveis no aeroporto. Isso significa que o agente de reservas de hotéis precisa coordenar-se com o agente de aluguel de carros para atender às preferências e restrições do usuário. Isso implica decidir *como os agentes coordenam suas ações*.
- **Arquitetura dos agentes**: Os agentes precisam ter uma estrutura interna para tomar decisões e aprender com as interações com o usuário. Por exemplo, o agente responsável por encontrar voos precisa ter a capacidade interna de decidir quais voos recomendar ao usuário. Isso significa que você precisa decidir *como os agentes tomam decisões e aprendem com as interações com o usuário*. Um exemplo de como um agente pode aprender e melhorar seria o uso de um modelo de aprendizado de máquina para recomendar voos com base nas preferências anteriores do usuário.
- **Visibilidade nas interações entre agentes**: É essencial ter visibilidade sobre como os múltiplos agentes estão interagindo entre si. Isso requer ferramentas e técnicas para rastrear as atividades e interações dos agentes. Isso pode incluir ferramentas de registro e monitoramento, ferramentas de visualização e métricas de desempenho.
- **Padrões para sistemas multiagentes**: Existem diferentes padrões para implementar sistemas multiagentes, como arquiteturas centralizadas, descentralizadas e híbridas. É necessário escolher o padrão que melhor se adapta ao seu caso de uso.
- **Humano no ciclo**: Na maioria dos casos, haverá um humano no ciclo, e será necessário instruir os agentes sobre quando pedir intervenção humana. Isso pode incluir, por exemplo, um usuário solicitando um hotel ou voo específico que os agentes não recomendaram ou pedindo confirmação antes de reservar um voo ou hotel.

## Visibilidade nas Interações entre Multiagentes

É importante ter visibilidade sobre como os múltiplos agentes estão interagindo entre si. Essa visibilidade é essencial para depurar, otimizar e garantir a eficácia geral do sistema. Para isso, é necessário ter ferramentas e técnicas para rastrear as atividades e interações dos agentes. Isso pode incluir ferramentas de registro e monitoramento, ferramentas de visualização e métricas de desempenho.

Por exemplo, no caso de reservar uma viagem para um usuário, você poderia ter um painel que mostra o status de cada agente, as preferências e restrições do usuário e as interações entre os agentes. Esse painel poderia exibir as datas de viagem do usuário, os voos recomendados pelo agente de voos, os hotéis recomendados pelo agente de hotéis e os carros de aluguel recomendados pelo agente de aluguel de carros. Isso daria uma visão clara de como os agentes estão interagindo entre si e se as preferências e restrições do usuário estão sendo atendidas.

Vamos analisar cada um desses aspectos com mais detalhes:

- **Ferramentas de Registro e Monitoramento**: É importante registrar cada ação tomada por um agente. Um registro pode armazenar informações sobre o agente que realizou a ação, a ação realizada, o horário em que a ação foi realizada e o resultado da ação. Essas informações podem ser usadas para depuração, otimização e mais.
- **Ferramentas de Visualização**: Ferramentas de visualização podem ajudar a entender as interações entre os agentes de forma mais intuitiva. Por exemplo, um gráfico que mostra o fluxo de informações entre os agentes pode ajudar a identificar gargalos, ineficiências e outros problemas no sistema.
- **Métricas de Desempenho**: Métricas de desempenho ajudam a monitorar a eficácia do sistema multiagente. Por exemplo, você pode rastrear o tempo necessário para concluir uma tarefa, o número de tarefas concluídas por unidade de tempo e a precisão das recomendações feitas pelos agentes. Essas informações podem ajudar a identificar áreas de melhoria e otimizar o sistema.

## Padrões para Multiagentes

Vamos explorar alguns padrões concretos que podem ser usados para criar aplicativos multiagentes. Aqui estão alguns padrões interessantes a considerar:

### Chat em Grupo

Esse padrão é útil quando você deseja criar um aplicativo de chat em grupo onde múltiplos agentes possam se comunicar entre si. Casos típicos de uso incluem colaboração em equipe, suporte ao cliente e redes sociais.

Nesse padrão, cada agente representa um usuário no chat em grupo, e as mensagens são trocadas entre os agentes usando um protocolo de mensagens. Os agentes podem enviar mensagens ao chat em grupo, receber mensagens do chat em grupo e responder a mensagens de outros agentes.

Esse padrão pode ser implementado usando uma arquitetura centralizada, onde todas as mensagens passam por um servidor central, ou uma arquitetura descentralizada, onde as mensagens são trocadas diretamente.

![Chat em grupo](../../../translated_images/multi-agent-group-chat.82d537c5c8dc833abbd252033e60874bc9d00df7193888b3377f8426449a0b20.pt.png)

### Transferência de Tarefas

Esse padrão é útil quando você deseja criar um aplicativo onde múltiplos agentes possam transferir tarefas entre si.

Casos típicos de uso incluem suporte ao cliente, gerenciamento de tarefas e automação de fluxos de trabalho.

Nesse padrão, cada agente representa uma tarefa ou etapa em um fluxo de trabalho, e os agentes podem transferir tarefas para outros agentes com base em regras predefinidas.

![Transferência de tarefas](../../../translated_images/multi-agent-hand-off.ed4f0a5a58614a8a3e962fc476187e630a3ba309d066e460f017b503d0b84cfc.pt.png)

### Filtragem Colaborativa

Esse padrão é útil quando você deseja criar um aplicativo onde múltiplos agentes possam colaborar para fazer recomendações aos usuários.

A razão para ter múltiplos agentes colaborando é que cada agente pode ter uma especialização diferente e contribuir de maneiras distintas para o processo de recomendação.

Vamos tomar como exemplo um usuário que deseja uma recomendação sobre a melhor ação para comprar no mercado financeiro.

- **Especialista em indústria**: Um agente pode ser especialista em um setor específico.
- **Análise técnica**: Outro agente pode ser especialista em análise técnica.
- **Análise fundamentalista**: E outro agente pode ser especialista em análise fundamentalista. Colaborando, esses agentes podem fornecer uma recomendação mais abrangente ao usuário.

![Recomendação](../../../translated_images/multi-agent-filtering.719217d169391ddb118bbb726b19d4d89ee139f960f8749ccb2400efb4d0ce79.pt.png)

## Cenário: Processo de Reembolso

Considere um cenário em que um cliente está tentando obter o reembolso de um produto. Pode haver diversos agentes envolvidos nesse processo, mas vamos dividi-los entre agentes específicos para esse processo e agentes gerais que podem ser usados em outros processos.

**Agentes específicos para o processo de reembolso**:

Abaixo estão alguns agentes que poderiam estar envolvidos no processo de reembolso:

- **Agente do cliente**: Representa o cliente e é responsável por iniciar o processo de reembolso.
- **Agente do vendedor**: Representa o vendedor e é responsável por processar o reembolso.
- **Agente de pagamento**: Representa o processo de pagamento e é responsável por reembolsar o pagamento do cliente.
- **Agente de resolução**: Representa o processo de resolução e é responsável por resolver quaisquer problemas que surjam durante o processo de reembolso.
- **Agente de conformidade**: Representa o processo de conformidade e é responsável por garantir que o processo de reembolso esteja em conformidade com regulamentos e políticas.

**Agentes gerais**:

Esses agentes podem ser usados em outras partes do seu negócio.

- **Agente de envio**: Representa o processo de envio e é responsável por enviar o produto de volta ao vendedor. Esse agente pode ser usado tanto no processo de reembolso quanto no envio geral de um produto, como em uma compra.
- **Agente de feedback**: Representa o processo de feedback e é responsável por coletar feedback do cliente. O feedback pode ser coletado a qualquer momento, não apenas durante o processo de reembolso.
- **Agente de escalonamento**: Representa o processo de escalonamento e é responsável por escalar problemas para um nível superior de suporte. Esse tipo de agente pode ser usado em qualquer processo onde seja necessário escalar um problema.
- **Agente de notificações**: Representa o processo de notificações e é responsável por enviar notificações ao cliente em várias etapas do processo de reembolso.
- **Agente de análise**: Representa o processo de análise e é responsável por analisar dados relacionados ao processo de reembolso.
- **Agente de auditoria**: Representa o processo de auditoria e é responsável por auditar o processo de reembolso para garantir que ele esteja sendo conduzido corretamente.
- **Agente de relatórios**: Representa o processo de relatórios e é responsável por gerar relatórios sobre o processo de reembolso.
- **Agente de conhecimento**: Representa o processo de conhecimento e é responsável por manter uma base de conhecimento com informações relacionadas ao processo de reembolso. Esse agente pode ser útil tanto para reembolsos quanto para outras partes do seu negócio.
- **Agente de segurança**: Representa o processo de segurança e é responsável por garantir a segurança do processo de reembolso.
- **Agente de qualidade**: Representa o processo de qualidade e é responsável por garantir a qualidade do processo de reembolso.

Há uma grande variedade de agentes listados acima, tanto para o processo específico de reembolso quanto para os agentes gerais que podem ser usados em outras partes do seu negócio. Esperamos que isso lhe dê uma ideia de como decidir quais agentes usar em seu sistema multiagente.

## Tarefa

Qual seria uma boa tarefa para esta lição?

Projete um sistema multiagente para um processo de suporte ao cliente. Identifique os agentes envolvidos no processo, seus papéis e responsabilidades, e como eles interagem entre si. Considere tanto os agentes específicos para o processo de suporte ao cliente quanto os agentes gerais que podem ser usados em outras partes do seu negócio.

> Pense um pouco antes de ler a solução abaixo; você pode precisar de mais agentes do que imagina.

> TIP: Pense nas diferentes etapas do processo de suporte ao cliente e também considere os agentes necessários para qualquer sistema.

## Solução

[Solução](./solution/solution.md)

## Verificações de Conhecimento

Pergunta: Quando você deve considerar o uso de multiagentes?

- [] A1: Quando você tem uma carga de trabalho pequena e uma tarefa simples.
- [] A2: Quando você tem uma grande carga de trabalho.
- [] A3: Quando você tem uma tarefa simples.

[Quiz de solução](./solution/solution-quiz.md)

## Resumo

Nesta lição, exploramos o padrão de design para multiagentes, incluindo os cenários onde os multiagentes são aplicáveis, as vantagens de usar multiagentes em vez de um único agente, os componentes fundamentais para implementar o padrão de design para multiagentes e como ter visibilidade sobre como os múltiplos agentes estão interagindo entre si.

## Recursos adicionais

- [Padrões de design Autogen](https://microsoft.github.io/autogen/stable/user-guide/core-user-guide/design-patterns/intro.html)
- [Padrões de design agentic](https://www.analyticsvidhya.com/blog/2024/10/agentic-design-patterns/)
```

**Aviso Legal**:
Este documento foi traduzido usando serviços de tradução automática baseados em IA. Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritária. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução.