Guia AutoGPT: Criação e implantação de agentes autônomos de IA localmente

A plataforma AutoGPT é uma plataforma que permite aos usuários criar, implementar e gerenciar agentes de IA contínuos. Ele usa uma interface de usuário com pouco código para permitir que os usuários automatizem milhares de processos digitais, com agentes executados de forma autônoma nos bastidores.

A plataforma AutoGPT tem dois componentes principais: o AutoGPT Server, a lógica e a infraestrutura principais, e o AutoGPT Frontend, a interface do usuário para criar os agentes, gerenciar fluxos de trabalho e implementar programações recorrentes. 

Ele é pré-integrado a provedores de LLM, como OpenAI, Anthropic, Groq e Llama, para que você possa automatizar uma ampla gama de tarefas, como processamento de dados, criação de conteúdo ou até mesmo atividades divertidas. 

Neste tutorial, orientaremos os profissionais técnicos sobre como configurar a plataforma AutoGPT localmente e criar seu primeiro agente. Você pode ler nosso guia completo sobre Entendendo os agentes de IA para saber mais e também descobrir os diferentes tipos de agentes de IA em um artigo separado. 

O que é o AutoGPT?

O AutoGPT é uma plataforma/software de IA que permite aos usuários criar, implementar e gerenciar agentes autônomos de IA. Esses agentes podem executar várias tarefas com supervisão humana mínima por meio de uma interface de baixo código instalada na máquina do usuário. 

No momento em que escrevo, há uma lista de espera aberta para uma próxima versão em nuvem do AutoGPT, se você quiser evitar o incômodo da configuração local.

Os principais recursos e capacidades do AutGPT incluem:

• Fluxos de trabalho com pouco código: Crie fluxos de trabalho sem precisar de muito conhecimento de codificação.
• Operação autônoma: Implemente agentes que são executados continuamente, ativando-se em acionadores específicos.
• Automação inteligente: Automatize processos repetitivos para processamento de dados, criação de conteúdo e outras tarefas.
• Sistema baseado em blocos: Crie agentes usando blocos modulares que representam diferentes ações e integrações.
• Suporte a vários LLMs: Compatível com OpenAI, Anthropic, Groq e Llama.
• Marketplace: Acesse agentes pré-configurados para casos de uso específicos.

Visão geral da arquitetura do AutoGPT

A plataforma AutoGPT consiste em dois componentes principais:

1. Servidor AutoGPT:

• Lógica central para agentes e automação
• Infraestrutura para desempenho confiável
• Marketplace para agentes pré-construídos

2. Frontend do AutoGPT:

• Criador de agentes para projetar e configurar agentes
• Ferramentas de gerenciamento de fluxo de trabalho
• Controles de implantação
• Seleção de agentes prontos para uso
• Painel de monitoramento e análise

O backend do AutoGPT usa Python com FastAPI como estrutura da Web e PostgreSQL com Prisma ORM para armazenamento de dados. Ele usa websockets para comunicação em tempo real e inclui gerentes para execução, agendamento e notificações. 

Esse design melhora a escalabilidade e a manutenção à medida que a plataforma cresce.

O front-end usa Next.js 14 com TypeScript, componentes Radix e Tailwind CSS, com visualização de fluxo de trabalho usando xyflow. Isso cria uma interface intuitiva e de baixo código, na qual os usuários podem criar agentes de IA sem conhecimento extenso de programação.

A plataforma inclui esses serviços essenciais:

• Gerenciador de banco de dados: Armazena configurações de agentes e dados de execução
• Gerenciador de execução: Executa fluxos de trabalho e gerencia o estado do agente
• Agendador: Lida com automação baseada em tempo e tarefas recorrentes
• Servidor Websocket: Fornece atualizações em tempo real
• API REST: Oferece acesso programático aos recursos
• Protocolo do agente: Padroniza a comunicação com serviços externos
• APIs de integração: Conecta-se a serviços de terceiros e provedores de IA

AutoGPT em 2025 vs. versões anteriores

Quando foi anunciado pela primeira vez, por volta de 2023, o AutoGPT explodiu em popularidade e foi visto como o assassino de código aberto do ChatGPT. É claro que isso foi apenas um exagero impulsionado por influenciadores de mídia social, porque agora é 2025, e o ChatGPT ainda está aqui. Mas o AutoGPT sinalizou a mudança de foco da comunidade de IA para os agentes de IA.

As versões anteriores do AutoGPT prometiam agentes totalmente autônomos que poderiam ser criados em tempo real a partir de um único prompt. Ele seria capaz de dividir o prompt em tarefas gerenciáveis e reunir uma variedade de ferramentas, software e APIs para realizar o trabalho, ao mesmo tempo em que teria a memória de curto e longo prazo impulsionada pelo loop de feedback de autorreflexão. 

Entretanto, ao longo do caminho, eles devem ter percebido as limitações dessa abordagem devido à imprevisibilidade inerente dos LLMs em cenários de produção.

Hoje, o AutoGPT não é uma plataforma "prompt-to-agent", mas algo muito melhor: uma plataforma de baixo código que coloca os usuários no controle de como seus agentes são criados. Você pode ver essa mudança da versão original do AutoGPT para a plataforma que temos em 2025 se ler as postagens de 1 a 2 anos atrás ou assistir aos vídeos do YouTube. 

Essas publicações mostram instruções de configuração e exemplos de fluxo de trabalho completamente diferentes do que estou prestes a ensinar a você.

Então, sem mais delongas, vamos ver como você pode configurar a plataforma em sua máquina.

Instalação e configuração do AutoGPT

A instalação do AutoGPT localmente requer a configuração adequada do seu ambiente de desenvolvimento e um conhecimento das ferramentas de conteinerização - confira nosso curso sobre conteinerização e virtualização com Docker e Kubernetes se você precisar de uma atualização. Esta seção orienta você no processo completo, desde os pré-requisitos até a execução da plataforma pela primeira vez.

Pré-requisitos e configuração do ambiente

Antes de instalar o AutoGPT, verifique se você tem os seguintes pré-requisitos:

1. Node.js e NPM

• Mac:
• brew install node
• Linux/WSL2:
• sudo apt update sudo apt install nodejs npm
• Verifique a instalação:
• node -v npm -v

2. Docker e Docker Compose

• Mac: Faça o download e instale o DockerDesktop
• Linux (o WSL2 já vem com o kernel do Docker e precisa ser instalado):
• sudo apt update sudo apt install docker.io docker-compose sudo systemctl enable --now docker
• Verifique a instalação:
• docker -v docker compose -v

3. Git

• Mac:
• brew install git
• Linux/WSL2:
• sudo apt update sudo apt install git

Clone o repositório AutoGPT:

git clone https://github.com/Significant-Gravitas/AutoGPT.git

Esses pré-requisitos são essenciais para que você execute o AutoGPT com eficiência. O Node.js e o NPM são necessários para o aplicativo front-end, permitindo que você interaja com o AutoGPT por meio de uma interface amigável. 

O Docker e o Docker Compose criam contêineres isolados que garantem um desempenho consistente em diferentes sistemas e simplificam a implantação dos serviços de back-end. O Git permite que você clone o repositório e fique atualizado com as melhorias mais recentes.

Após essa etapa, você deve ter o diretório AutoGPT em sua máquina, que contém tudo para executar o aplicativo. A única coisa que resta é a configuração.

Hospedagem local com o Docker 

O Docker fornece um ambiente isolado e consistente para a execução do AutoGPT, garantindo que todas as dependências funcionem corretamente, independentemente do sistema host.

1. Configurar os serviços de back-end

cd AutoGPT/autogpt_platform
cp .env.example .env
docker compose up -d --build

O novo arquivo .env vem com variáveis de ambiente preenchidas com padrões sensatos. Não é estritamente necessário que você mesmo configure esse arquivo, mas sua presença é obrigatória. Ele será usado pelo aplicativo front-end quando você fornecer várias chaves e segredos ao criar seus agentes personalizados.

O último comando docker compose pode levar até 15 minutos, dependendo da velocidade da Internet na primeira execução. Ele configura os componentes de backend aos quais o frontend se conectará.

2. Configure o aplicativo de front-end

cd frontend
cp .env.example .env
npm install
npm run dev

Esses comandos configuram o arquivo de ambiente para o frontend, instalam suas dependências com o Node.js e iniciam a interface do usuário.

3. Verifique a instalação

• Acesse a interface do usuário do AutoGPT em http://localhost:3000
• Os serviços de back-end são executados em portas:
• WebSocket Server: 8001
• API de execução: 8006

A visita à porta 3000 deve mostrar a interface do usuário do Marketplace, por meio da qual você deve criar sua conta e fazer login.

4. Personalize sua chave de criptografia (opcional, mas recomendado)

# Generate a new key with Python
from cryptography.fernet import Fernet
Fernet.generate_key().decode()

# Or use the built-in CLI
poetry run cli gen-encrypt-key

Substitua a chave existente em autogpt_platform/backend/.env pela nova chave.

Observação para usuários do Windows: Ao usar o Docker no Windows, selecione WSL2 em vez de Hyper-V durante a instalação para evitar problemas de compatibilidade com o Supabase. Se você já tiver instalado com o Hyper-V, poderá mudar para o WSL 2 nas configurações do Docker Desktop.

Visão geral da interface de usuário do AutoGPT

Antes de criarmos um agente funcional, vamos ter uma ideia da interface do construtor do AutGPT.

A interface é uma grande tela em branco com quatro botões principais:

• Blocos
• Botões de desfazer/refazer
• Salvar

Ao clicar em "Blocks", você verá um menu com os componentes reutilizáveis incorporados do AutoGPT, agrupados em categorias.

Esses blocos fornecem ferramentas essenciais que podem ser aplicadas universalmente em muitos cenários de agentes. 

Por exemplo, abaixo, pesquisei e adicionei dois blocos: entrada de texto longo e gerador de texto de IA. Esses dois componentes são suficientes para que eu possa recriar a versão básica da interface do ChatGPT:

Observando a imagem, você pode ver que cada bloco tem diferentes partes móveis. O bloco de entrada tem campos para o nome do bloco e um valor padrão, enquanto o gerador de texto tem um campo para o prompt, o modelo e as variáveis do prompt. 

O último também tem um campo de entrada única para sua chave de API da OpenAI, que você deve fornecer antes de executar o agente (faça isso agora). O campo da chave da API muda com base no modelo que você escolher e o AutoGPT é compatível com a maioria dos fornecedores principais e secundários.

Se você notar, os dois blocos têm pequenas bordas (veja 3 e 5) que permitem que você os conecte:

Na imagem acima, estou dando ao bloco de entrada um nome (1) e um valor padrão (2), e conectando seu resultado de texto (3) ao campo de prompt (4) do gerador de texto. Essa conexão cria um fluxo de trabalho básico do agente, que pode ser executado após você salvar o próprio agente (etapas 5 a 8).

Depois de clicar em executar, você verá um menu pop-up "Run settings" (Configurações de execução) para o campo de entrada:

Escreva seu prompt e execute tudo para obter o primeiro resultado, como abaixo:

Você pode notar que a resposta do modelo é difícil de ler dentro do bloco de geração de texto maior. É por isso que o AutoGPT tem blocos para saídas de agentes, que estou adicionando abaixo:

Observe como eu conectei o campo de resposta do gerador de texto ao valor do bloco de saída do agente. A adição de um bloco de saída também permite que você visualize todas as saídas de agentes de diferentes blocos usando o painel "Agent Outputs" em um único local:

Quando você salvar seu agente, ele será salvo na sua biblioteca. Além disso, todo esse agente pode ser usado como um bloco em outros agentes que você criar. Essa abordagem modular oferece várias vantagens:

1. Reusabilidade: Você pode reutilizar funcionalidades complexas em vários projetos sem precisar reconstruí-las.
2. Composability: Você pode combinar diferentes agentes para criar fluxos de trabalho mais sofisticados.
3. Mantenabilidade: Quando você atualizar o agente original, todas as instâncias que o utilizam como um bloco se beneficiarão das melhorias.
4. Abstração: Os processos complexos podem ser encapsulados em um único bloco, tornando os fluxos de trabalho dos agentes principais mais limpos e fáceis de entender.
5. Colaboração: Você pode compartilhar blocos de agentes especializados com colegas de equipe ou com a comunidade, acelerando o desenvolvimento.

Essa abordagem de blocos de construção permite que você crie sistemas de IA cada vez mais avançados, colocando os recursos em camadas uns sobre os outros.

Como escrever blocos personalizados no AutoGPT em Python

Visão geral da sintaxe e do processo geral

O poder do AutoGPT vem de seu sistema de blocos modulares. Embora a plataforma inclua muitos blocos internos úteis, você pode ampliar seus recursos criando seus próprios blocos personalizados em Python. Esse recurso permite que você se integre a qualquer API, serviço ou ferramenta que possa ser acessada programaticamente.

A criação de um bloco personalizado envolve estas etapas essenciais:

1. Crie um novo arquivo Python no diretório , usando a nomenclatura snake_case. no diretório autogpt_platform/backend/backend/blocks usando a nomenclatura snake_case
2. Defina uma classe que herda da classe base Block
3. Criar esquemas de entrada e saída Usar o site BlockSchema para definir a estrutura de dados
4. Implemente o método __init__ com um ID exclusivo e dados de teste
5. Escreva o método run que contém a lógica central do seu bloco
6. Tratar os erros adequadamente para garantir que o bloco falhe de forma adequada
7. Teste seu bloco usando a infraestrutura de testes da plataforma

Vamos analisar cada componente em detalhes:

Estrutura de classe de bloco

Cada bloco deve herdar da classe base Block e definir seus esquemas de entrada/saída:

from backend.data.block import Block, BlockSchema, BlockOutput

class MyCustomBlock(Block):
   class Input(BlockSchema):
       # Define input fields with types
       field1: str
       field2: int
      
   class Output(BlockSchema):
       # Define output fields with types
       result: str
       error: str  # Always include an error field
      
   def __init__(self):
       super().__init__(
           id="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",  # Generate proper UUID
           input_schema=MyCustomBlock.Input,
           output_schema=MyCustomBlock.Output,
           test_input={"field1": "test", "field2": 42},
           test_output=("result", "expected output"),
           test_mock=None  # Only needed for external API calls
       )
      
   def run(self, input_data: Input, **kwargs) -> BlockOutput:
       try:
           # Your block logic here
           result = f"Processed {input_data.field1} and {input_data.field2}"
           yield "result", result
       except Exception as e:
           raise RuntimeError(f"Error in block: {str(e)}")

Componentes importantes

1. Esquemas de entrada/saída: Definir a estrutura de dados usando dicas de tipo
2. Geração de UUID: Use um gerador de UUID adequado (não invente o seu próprio)
3. Dados de teste: Forneça entradas de teste realistas e resultados esperados
4. Tratamento de erros: Sempre inclua o tratamento adequado de erros no método de execução
5. Resultados: Use yield para gerar resultados um de cada vez

Um exemplo de bloco personalizado

Vamos criar um exemplo detalhado de um bloco personalizado que realiza análise de sentimento usando a API OpenAI. Isso demonstra como você pode se integrar a serviços externos de IA e lidar com chaves de API de forma segura.

Instruções de configuração para a chave da API da OpenAI

Antes de usar esse bloco, você precisa configurar sua chave de API da OpenAI:

1. Instale os pacotes necessários:

• pip install openai python-dotenv

2. Crie um arquivo .env no diretório autogpt_platform/backend/blocks com sua chave de API da OpenAI:

• OPENAI_API_KEY=your_api_key_here

Agora, vamos criar o bloco:

Importar dependências e configurar o ambiente

Primeiro, vamos tratar das importações e da configuração do ambiente:

# autogpt_platform/backend/blocks/sentiment_analyzer.py
from backend.data.block import Block, BlockSchema, BlockOutput
from typing import Dict, Any, List
import os
from dotenv import load_dotenv
from openai import OpenAI
import json

# Load environment variables from .env file
load_dotenv()

Esta seção importa as bibliotecas necessárias e carrega as variáveis de ambiente do arquivo .env. A função load_dotenv() garante que sua chave de API esteja disponível em os.getenv().

Definir o esquema de blocos e inicializar

Em seguida, definimos a classe de bloco com esquemas de entrada e saída:

class OpenAISentimentBlock(Block):
   """Block to analyze sentiment of text using OpenAI API"""
  
   class Input(BlockSchema):
       text: str  # Text to analyze
       model: str = "gpt-3.5-turbo"  # OpenAI model to use
       detailed_analysis: bool = False  # Whether to return detailed analysis
      
   class Output(BlockSchema):
       sentiment: str  # Positive, Negative, or Neutral
       confidence: float  # Confidence score of the prediction
       explanation: str  # Brief explanation of the sentiment
       detailed_analysis: Dict[str, Any]  # Optional detailed analysis
       error: str  # Error message if analysis fails

O esquema de entrada define três parâmetros:

• text: O conteúdo a ser analisado (obrigatório)
• model: O modelo OpenAI a ser usado (o padrão é "gpt-3.5-turbo")
• detailed_analysis: Se você deseja retornar detalhes adicionais (o padrão é False)

O esquema de saída define a estrutura dos resultados, incluindo a categoria de sentimento, a pontuação de confiança, a explicação e a análise detalhada opcional.

Inicializar o bloco com dados de teste

O método __init__ configura o bloco com dados de teste e inicializa o cliente OpenAI:

def __init__(self):
   super().__init__(
       id="8f67d394-9f52-4352-a78b-175d5d1d7182",  # Generated UUID
       input_schema=OpenAISentimentBlock.Input,
       output_schema=OpenAISentimentBlock.Output,
       test_input={
           "text": "I really enjoyed this product, it exceeded my expectations!",
           "detailed_analysis": True
       },
       test_output=[
           ("sentiment", str),
           ("confidence", float),
           ("explanation", str),
           ("detailed_analysis", dict)
       ],
       test_mock={
           "_analyze_sentiment": lambda text, model, detailed: {
               "sentiment": "positive",
               "confidence": 0.92,
               "explanation": "The text expresses clear enjoyment and states that expectations were exceeded.",
               "detailed_analysis": {
                   "emotions": {
                       "joy": "high",
                       "satisfaction": "high",
                       "disappointment": "none"
                   },
                   "key_phrases": ["really enjoyed", "exceeded expectations"],
                   "tone": "enthusiastic"
               }
           }
       }
   )
   # Initialize OpenAI client
   api_key = os.getenv("OPENAI_API_KEY")
   if not api_key:
       raise RuntimeError("OpenAI API key not found. Please set OPENAI_API_KEY in .env file.")
   self.client = OpenAI(api_key=api_key)

Este método:

• Estabelece entradas de teste realistas e resultados esperados para o teste
• Fornece uma simulação para a função de análise de sentimento para evitar chamadas de API durante o teste
• Inicializa o cliente OpenAI com a chave de API das variáveis de ambiente
• Lança um erro se a chave da API estiver faltando

Implementar o método de análise de sentimentos

A funcionalidade principal é implementada no método _analyze_sentiment:

@staticmethod
def _analyze_sentiment(self, text: str, model: str, detailed: bool) -> Dict[str, Any]:
   """Analyze sentiment using OpenAI API"""
   # Create prompt based on whether detailed analysis is requested
   if detailed:
       system_prompt = """
       You are a sentiment analysis expert. Analyze the following text and provide:
       1. The overall sentiment (positive, negative, or neutral)
       2. A confidence score from 0.0 to 1.0
       3. A brief explanation of your assessment
       4. A detailed analysis including:
          - Key emotions detected and their intensity
          - Key phrases that influenced your assessment
          - Overall tone of the text
      
       Format your response as a JSON object with the following structure:
       {
           "sentiment": "positive|negative|neutral",
           "confidence": 0.0-1.0,
           "explanation": "brief explanation",
           "detailed_analysis": {
               "emotions": {"emotion1": "intensity", "emotion2": "intensity"},
               "key_phrases": ["phrase1", "phrase2"],
               "tone": "description of tone"
           }
       }
       """
   else:
       system_prompt = """
       You are a sentiment analysis expert. Analyze the following text and provide:
       1. The overall sentiment (positive, negative, or neutral)
       2. A confidence score from 0.0 to 1.0
       3. A brief explanation of your assessment
      
       Format your response as a JSON object with the following structure:
       {
           "sentiment": "positive|negative|neutral",
           "confidence": 0.0-1.0,
           "explanation": "brief explanation"
       }
       """
  
   try:
       # Make API call using the latest OpenAI API syntax
       response = self.client.chat.completions.create(
           model=model,
           response_format={"type": "json_object"},
           messages=[
               {"role": "system", "content": system_prompt},
               {"role": "user", "content": text}
           ],
           temperature=0.2  # Low temperature for more consistent results
       )
      
       # Extract and parse JSON response
       content = response.choices[0].message.content
       result = json.loads(content)
      
       return result
      
   except Exception as e:
       raise RuntimeError(f"OpenAI API error: {str(e)}")

Este método:

• Cria um prompt de sistema diferente com base na solicitação de análise detalhada
• Usa a API OpenAI para gerar uma análise de sentimento estruturada
• Define uma temperatura baixa (0,2) para obter resultados mais consistentes
• Analisa a resposta JSON e a retorna
• Trata as exceções que podem ocorrer durante a chamada à API

Implementar o método de execução

Por fim, o método run une tudo:

def run(self, input_data: Input, **kwargs) -> BlockOutput:
   try:
       # Validate input
       if not input_data.text or not isinstance(input_data.text, str):
           raise ValueError("Text must be a non-empty string")
      
       # Process through OpenAI
       results = self._analyze_sentiment(
           input_data.text,
           input_data.model,
           input_data.detailed_analysis
       )
      
       # Yield the results
       yield "sentiment", results["sentiment"]
       yield "confidence", results["confidence"]
       yield "explanation", results["explanation"]
      
       # Only return detailed analysis if requested and available
       if input_data.detailed_analysis and "detailed_analysis" in results:
           yield "detailed_analysis", results["detailed_analysis"]
      
   except ValueError as e:
       raise RuntimeError(f"Input validation error: {str(e)}")
   except Exception as e:
       raise RuntimeError(f"Sentiment analysis failed: {str(e)}")

Este método:

• Valida o texto de entrada
• Chama o método de análise de sentimento com os parâmetros de entrada
• Produz os resultados um a um usando a palavra-chave yield
• Só fornece análises detalhadas se elas forem solicitadas e estiverem disponíveis
• Trata diferentes tipos de erros com mensagens apropriadas

Principais aspectos deste exemplo

1. Integração da API OpenAI: Usa a sintaxe mais recente da API da OpenAI com o ponto de extremidade de conclusões de bate-papo
2. Manuseio seguro de chaves de API: Carrega a chave de API das variáveis de ambiente usando dotenv
3. Análise personalizável: Oferece análise de sentimento básica ou detalhada com base na preferência do usuário
4. Saída estruturada: Retorna a categoria de sentimento, a pontuação de confiança, a explicação e a análise detalhada opcional
5. Processamento de JSON: Lida com respostas JSON estruturadas da OpenAI
6. Estratégia de teste: Simula a chamada da API da OpenAI para testes sem usar os créditos reais da API

Este bloco demonstra como fazer a integração com serviços de IA de última geração para aprimorar os recursos de seus agentes. A integração do OpenAI permite uma análise de texto sofisticada que seria difícil de implementar com abordagens simples baseadas em regras.

Ao escrever seus próprios bloqueios, sempre leve em consideração:

• Como lidar com chaves de API de forma segura
• Fornecimento de mensagens de erro claras para falhas de API
• Projetar entradas que permitam flexibilidade na forma como o bloco é usado
• Estruturar os resultados para serem facilmente consumidos por blocos posteriores

Para obter informações mais detalhadas sobre a criação de blocos personalizados, incluindo tipos de campo, autenticação, integração de webhook e práticas recomendadas, consulte a documentação oficial do AutoGPT Block.

Conclusão

O AutoGPT oferece uma plataforma avançada para criar e implementar agentes autônomos de IA por meio de sua interface intuitiva baseada em blocos. Este tutorial guiou você por todo o processo, desde a instalação e configuração local até a compreensão da interface do usuário, a criação de agentes básicos e a ampliação da funcionalidade com blocos personalizados. 

Ao adotar a arquitetura modular do AutoGPT, os profissionais técnicos podem automatizar fluxos de trabalho complexos sem um amplo conhecimento de codificação e, ao mesmo tempo, ter a flexibilidade de adicionar recursos personalizados quando necessário.

Para aqueles que desejam desenvolver essa base e explorar mais os agentes de IA, a documentação oficial do AutoGPT fornece orientações abrangentes, enquanto o DataCamp oferece recursos complementares como Understanding AI Agents e ChatGPT Fundamentals. 

O curso Introduction to GPTs pode ajudar a solidificar sua compreensão de modelos de linguagem grandes, enquanto o Building RAG Chatbots for Technical Documentation demonstra outra aplicação prática de agentes de IA. À medida que você continua a fazer experiências com agentes de IA, talvez queira conferir novas ferramentas como Mistral Agents API, Dify AI e Langflow.