Autogpt Agents

AutoGPT - Plataforma de Agentes de IA Autônomos

Plataforma abrangente para construir, implantar e gerenciar agentes de IA contínuos através de uma interface visual ou kit de desenvolvimento.

Quando usar AutoGPT

Use AutoGPT quando:

• Construindo agentes autônomos que rodam continuamente
• Criando agentes de IA baseados em workflow visual
• Implantando agentes com triggers externos (webhooks, agendamentos)
• Construindo pipelines complexos de automação com múltiplas etapas
• Necessitando de um agent builder sem código/baixo código

Principais características:

• Visual Agent Builder: Editor de workflow baseado em nós com drag-and-drop
• Execução Contínua: Agentes rodam persistentemente com triggers
• Marketplace: Agentes pré-construídos e blocos para compartilhar/reutilizar
• Sistema de Blocos: Componentes modulares para LLM, ferramentas, integrações
• Forge Toolkit: Ferramentas de desenvolvimento para criação customizada de agentes
• Sistema de Benchmark: Testes padronizados de desempenho de agentes

Use alternativas em vez disso:

• LangChain/LlamaIndex: Se você precisa de mais controle sobre a lógica do agente
• CrewAI: Para colaboração multi-agente baseada em papéis
• OpenAI Assistants: Para implantações simples de agentes hospedados
• Semantic Kernel: Para integração com ecossistema Microsoft

Início rápido

Instalação (Docker)

# Clone repositório
git clone https://github.com/Significant-Gravitas/AutoGPT.git
cd AutoGPT/autogpt_platform

# Copie arquivo de ambiente
cp .env.example .env

# Inicie serviços backend
docker compose up -d --build

# Inicie frontend (em terminal separado)
cd frontend
cp .env.example .env
npm install
npm run dev

Acesse a plataforma

• Interface Frontend: http://localhost:3000
• API Backend: http://localhost:8006/api
• WebSocket: ws://localhost:8001/ws

Visão geral da arquitetura

AutoGPT possui dois sistemas principais:

AutoGPT Platform (Produção)

• Agent builder visual com frontend React
• Backend FastAPI com execution engine
• Infraestrutura PostgreSQL + Redis + RabbitMQ

AutoGPT Classic (Desenvolvimento)

• Forge: Kit de desenvolvimento de agentes
• Benchmark: Framework de testes de desempenho
• CLI: Interface de linha de comando para desenvolvimento

Conceitos principais

Graphs e nodes

Agentes são representados como graphs contendo nodes conectados por links:

Graph (Agent)
  ├── Node (Input)
  │   └── Block (AgentInputBlock)
  ├── Node (Process)
  │   └── Block (LLMBlock)
  ├── Node (Decision)
  │   └── Block (SmartDecisionMaker)
  └── Node (Output)
      └── Block (AgentOutputBlock)

Blocos

Blocos são componentes funcionais reutilizáveis:

Fluxo de execução

User/Trigger → Graph Execution → Node Execution → Block.execute()
     ↓              ↓                 ↓
  Inputs      Queue System      Output Yields

Construindo agentes

Usando o agent builder visual

1. Abra Agent Builder em http://localhost:3000
2. Adicione blocos do painel BlocksControl
3. Conecte nodes arrastando entre handles
4. Configure inputs em cada node
5. Execute agente usando PrimaryActionBar

Blocos disponíveis

Blocos de IA:

• AITextGeneratorBlock - Gere texto com LLMs
• AIConversationBlock - Conversas multi-turno
• SmartDecisionMakerBlock - Lógica condicional

Blocos de Integração:

• Conectores GitHub, Google, Discord, Notion
• Triggers webhook e handlers
• Blocos de requisição HTTP

Blocos de Controle:

• Blocos de Input/Output
• Nós de branching e decisão
• Blocos de loop e iteração

Execução do agente

Tipos de trigger

Execução manual:

POST /api/v1/graphs/{graph_id}/execute
Content-Type: application/json

{
  "inputs": {
    "input_name": "value"
  }
}

Trigger webhook:

POST /api/v1/webhooks/{webhook_id}
Content-Type: application/json

{
  "data": "webhook payload"
}

Execução agendada:

{
  "schedule": "0 */2 * * *",
  "graph_id": "graph-uuid",
  "inputs": {}
}

Monitorando execução

Atualizações WebSocket:

const ws = new WebSocket('ws://localhost:8001/ws');

ws.onmessage = (event) => {
  const update = JSON.parse(event.data);
  console.log(`Node ${update.node_id}: ${update.status}`);
};

REST API polling:

GET /api/v1/executions/{execution_id}

Usando Forge (Desenvolvimento)

Crie agente customizado

# Configure ambiente forge
cd classic
./run setup

# Crie novo agente a partir de template
./run forge create my-agent

# Inicie servidor do agente
./run forge start my-agent

Estrutura do agente

my-agent/
├── agent.py          # Lógica principal do agente
├── abilities/        # Habilidades customizadas
│   ├── __init__.py
│   └── custom.py
├── prompts/          # Templates de prompt
└── config.yaml       # Configuração do agente

Implemente habilidade customizada

from forge import Ability, ability

@ability(
    name="custom_search",
    description="Search for information",
    parameters={
        "query": {"type": "string", "description": "Search query"}
    }
)
def custom_search(query: str) -> str:
    """Custom search ability."""
    # Implemente lógica de busca
    result = perform_search(query)
    return result

Benchmarking de agentes

Execute benchmarks

# Execute todos os benchmarks
./run benchmark

# Execute categoria específica
./run benchmark --category coding

# Execute com agente específico
./run benchmark --agent my-agent

Categorias de benchmark

• Coding: Geração e debug de código
• Retrieval: Busca de informações
• Web: Navegação e interação na web
• Writing: Tarefas de geração de texto

VCR cassettes

Benchmarks usam respostas HTTP gravadas para reprodutibilidade:

# Grave cassettes novos
./run benchmark --record

# Execute com cassettes existentes
./run benchmark --playback

Integrações

Adicionando credenciais

1. Navegue para Profile > Integrations
2. Selecione provider (OpenAI, GitHub, Google, etc.)
3. Digite chaves de API ou autorize OAuth
4. Credenciais são criptografadas e armazenadas com segurança

Usando credenciais em blocos

Blocos acessam automaticamente credenciais do usuário:

class MyLLMBlock(Block):
    def execute(self, inputs):
        # Credenciais são injetadas pelo sistema
        credentials = self.get_credentials("openai")
        client = OpenAI(api_key=credentials.api_key)
        # ...

Providers suportados

Implantação

Setup Docker para produção

# docker-compose.prod.yml
services:
  rest_server:
    image: autogpt/platform-backend
    environment:
      - DATABASE_URL=postgresql://...
      - REDIS_URL=redis://redis:6379
    ports:
      - "8006:8006"

  executor:
    image: autogpt/platform-backend
    command: poetry run executor

  frontend:
    image: autogpt/platform-frontend
    ports:
      - "3000:3000"

Variáveis de ambiente

Gere chave de criptografia

cd autogpt_platform/backend
poetry run cli gen-encrypt-key

Melhores práticas

1. Comece simples: Comece com agentes de 3-5 nodes
2. Teste incrementalmente: Execute e teste após cada mudança
3. Use webhooks: Triggers externos para agentes orientados a eventos
4. Monitore custos: Rastreie uso de API de LLM via sistema de créditos
5. Versione agentes: Salve versões funcionando antes de mudanças
6. Benchmark: Use agbenchmark para validar qualidade do agente

Problemas comuns

Serviços não iniciando:

# Verifique status dos containers
docker compose ps

# Veja logs
docker compose logs rest_server

# Reinicie serviços
docker compose restart

Problemas de conexão com banco de dados:

# Execute migrações
cd backend
poetry run prisma migrate deploy

Execução do agente travada:

# Verifique fila RabbitMQ
# Visite http://localhost:15672 (guest/guest)

# Limpe execuções travadas
docker compose restart executor

Referências

• Advanced Usage - Blocos customizados, implantação, escalabilidade
• Troubleshooting - Problemas comuns, debug

Recursos

• Documentação: https://docs.agpt.co
• Repositório: https://github.com/Significant-Gravitas/AutoGPT
• Discord: https://discord.gg/autogpt
• License: MIT (Classic) / Polyform Shield (Platform)