Fundamentos de Agentes AI

🤖 O que são Agentes AI?

Um agente AI é um sistema de inteligência artificial que pode observar, pensar, decidir e agir de forma autónoma para alcançar objetivos específicos. Ao contrário de um chatbot tradicional que apenas responde a perguntas, um agente pode executar tarefas complexas, usar ferramentas externas e iterar até completar uma tarefa.

💡 Analogia

Pensa num agente AI como um assistente virtual que não só conversa contigo, mas também pode abrir aplicações, pesquisar na web, executar código e completar tarefas por ti.

Características Principais

👁️

Observação

O agente observa o ambiente, inputs do utilizador e resultados das suas próprias ações.

🧠

Raciocínio

Utiliza um LLM para processar informações e planear as próximas ações.

🛠️

Ferramentas

Pode executar ações através de ferramentas (APIs, bases de dados, browsers).

🔄

Iteração

Repete o ciclo até completar a tarefa ou atingir um limite de iterações.

🏗️ Arquitetura de um Agente

A arquitetura de um agente AI segue um ciclo de observação-pensamento-ação. Este padrão é frequentemente chamado de ReAct (Reasoning + Acting).

                            Diagrama
                        

                            ┌─────────────────────────────────────────────────────────────┐
│                      CICLO DO AGENTE                          │
│                                                              │
│    ┌──────────┐    ┌──────────┐    ┌──────────┐              │
│    │ OBSERVAR │───▶│ PENSAR   │───▶│ AGIR     │──┐          │
│    └──────────┘    └──────────┘    └──────────┘  │          │
│         ▲                               │         │          │
│         │                               ▼         │          │
│         │                         ┌──────────┐   │          │
│         │                         │ RESULTADO │   │          │
│         │                         └──────────┘   │          │
│         │                               │         │          │
│         └───────────────────────────────┴─────────┘          │
│                                                              │
│    OBSERVAR: Recebe input do utilizador ou ambiente          │
│    PENSAR:   O LLM raciocina e decide a próxima ação         │
│    AGIR:     Executa uma ferramenta ou retorna resposta      │
│    RESULTADO: Observa o resultado e repete se necessário     │
│                                                              │
└─────────────────────────────────────────────────────────────┘
                        

O Ciclo ReAct

1. Observação (Observe): O agente recebe input do utilizador, consulta o seu estado interno ou observa resultados de ações anteriores.

2. Pensamento (Think): O LLM processa a observação, raciocina sobre o problema e planear a próxima ação.

3. Ação (Act): O agente executa uma ferramenta específica ou formula uma resposta final.

4. Repetição: O ciclo repete-se até a tarefa estar completa ou atingir um limite.

ℹ️ Exemplo Prático

Utilizador: "Qual é a população de Lisboa e qual seria se aumentasse 10%?"

Agente:

Observa: Recebe a pergunta
Pensa: "Preciso de pesquisar a população de Lisboa"
Age: Usa a ferramenta de pesquisa web
Observa: Encontra que Lisboa tem ~500.000 habitantes
Pensa: "Agora calculo 10% de 500.000"
Age: Usa a calculadora: 500.000 + (500.000 × 0.1) = 550.000
Resposta: "Lisboa tem aproximadamente 500.000 habitantes. Com um aumento de 10%, seriam 550.000."

🏷️ Tipos de Agentes

Os agentes podem ser classificados em diferentes categorias consoante a sua capacidade de raciocínio e autonomia.

Agentes Reativos

Os agentes reativos respondem diretamente aos inputs sem manter um estado interno complexo. São simples e eficientes, mas limitados em tarefas que exigem planeamento.

Python

# Exemplo de Agente Reativo Simples
def agente_reativo(pergunta):
    """Um agente que responde diretamente sem memória de contexto."""
    if "tempo" in pergunta.lower():
        return consultar_api_tempo()
    elif "calcula" in pergunta.lower():
        return calcular_expressao(pergunta)
    else:
        return "Não entendi a pergunta."

Agentes Deliberativos

Os agentes deliberativos mantêm um modelo interno do mundo e planear ações antes de executá-las. Utilizam raciocínio mais profundo mas são mais lentos.

Python

# Exemplo de Agente Deliberativo
class AgenteDeliberativo:
    def __init__(self):
        self.memoria = []
        self.objetivos = []

    def planear(self, objetivo):
        """Gera um plano de ação para alcançar o objetivo."""
        plano = []
        # Decompor objetivo em subtarefas
        subtarefas = self.decompor(objetivo)
        for subtarefa in subtarefas:
            plano.extend(self.gerar_acoes(subtarefa))
        return plano

    def executar_plano(self, plano):
        """Executa cada passo do plano sequencialmente."""
        resultados = []
        for acao in plano:
            resultado = self.executar_acao(acao)
            self.memoria.append(resultado)
            resultados.append(resultado)
        return resultados

Agentes Híbridos

Combinam elementos reativos e deliberativos. Respondem rapidamente a inputs simples mas utilizam raciocínio profundo para tarefas complexas.

Comparação de Tipos

                            Tabela Comparativa
                        

                            ┌────────────────┬─────────────┬─────────────┬─────────────┐
│   Característica │  Reativo    │ Deliberativo│   Híbrido   │
├────────────────┼─────────────┼─────────────┼─────────────┤
│ Velocidade     │    ⚡ Rápido │    🐢 Lento  │   ⚖️ Médio   │
│ Memória        │    ❌ Não    │    ✅ Sim    │   ✅ Sim     │
│ Planeamento    │    ❌ Não    │    ✅ Sim    │   ✅ Sim     │
│ Complexidade   │   🟢 Baixa   │  🔴 Alta     │  🟡 Média    │
│ Casos de Uso   │  Respostas  │  Planeamento │   Geral     │
│                │  simples    │  complexo    │             │
└────────────────┴─────────────┴─────────────┴─────────────┘
                        

🧩 Componentes Essenciais

Um agente AI completo é composto por vários componentes que trabalham em conjunto.

🧠 Modelo de Linguagem (LLM) ▼

O "cérebro" do agente. Processa inputs, raciocina e gera outputs. Exemplos: GPT-4, Claude, Llama, Mistral.

Python

# Configuração de LLM com Ollama
from langchain_community.llms import Ollama

llm = Ollama(model="llama3.1")
resposta = llm.invoke("Qual é a capital de Portugal?")

🛠️ Ferramentas (Tools) ▼

Funções que o agente pode invocar para executar ações no mundo real. Exemplos: pesquisa web, executar código, APIs externas.

Python

# Definição de uma ferramenta simples
from langchain.tools import Tool

def calculadora(expressao: str) -> str:
    """Calcula uma expressão matemática."""
    try:
        resultado = eval(expressao)
        return str(resultado)
    except Exception as e:
        return f"Erro: {e}"

ferramenta_calculadora = Tool(
    name="calculadora",
    description="Útil para cálculos matemáticos. Input: expressão matemática.",
    func=calculadora
)

📚 Memória ▼

Sistema para armazenar e recuperar informações. Pode ser de curto prazo (contexto da conversa) ou longo prazo (persistência).

Python

# Memória de curto prazo
class MemoriaCurtoPrazo:
    def __init__(self, limite_mensagens=10):
        self.mensagens = []
        self.limite = limite_mensagens

    def adicionar(self, mensagem):
        self.mensagens.append(mensagem)
        if len(self.mensagens) > self.limite:
            self.mensagens.pop(0)  # Remove a mais antiga

    def obter_contexto(self):
        return "\n".join(self.mensagens)

# Memória de longo prazo (com banco de dados)
class MemoriaLongoPrazo:
    def __init__(self, db_path="memoria.db"):
        # Implementação com SQLite ou similar
        pass

    def guardar(self, chave, valor):
        """Guarda informação para uso futuro."""
        pass

    def recuperar(self, query):
        """Recupera informação relevante."""
        pass

📋 Planeamento (Planning) ▼

Mecanismo para decompor tarefas complexas em subtarefas e planear a execução.

Python

# Sistema de planeamento simples
class Planeador:
    def decompor_tarefa(self, tarefa):
        """Decompõe uma tarefa em subtarefas."""
        prompt = f"""
        Decomponha a seguinte tarefa em subtarefas:
        Tarefa: {tarefa}

        Formate a resposta como uma lista JSON de subtarefas.
        """
        subtarefas = self.llm.invoke(prompt)
        return self.parse_subtarefas(subtarefas)

    def ordenar_tarefas(self, subtarefas):
        """Ordena subtarefas por dependências."""
        # Análise de dependências
        grafo = self.construir_grafo_dependencias(subtarefas)
        return self.ordenacao_topologica(grafo)

💬 Agentes vs Chatbots

Embora possam parecer semelhantes, há diferenças fundamentais entre um chatbot tradicional e um agente AI.

                            Comparação
                        

                            ┌──────────────────┬───────────────────────┬───────────────────────┐
│   Aspecto         │       Chatbot         │       Agente          │
├──────────────────┼───────────────────────┼───────────────────────┤
│ Comunicação      │ Conversa básica       │ Conversa contextual   │
│ Ações            │ Não executa ações     │ Executa tarefas       │
│ Ferramentas      │ Não tem ferramentas   │ Usa ferramentas       │
│ Memória          │ Limitada/nenhuma      │ Contexto persistente  │
│ Autonomia        │ Reativo               │ Proativo              │
│ Iteração         │ Uma resposta          │ Múltiplas iterações   │
│ Objetivo         │ Responder perguntas   │ Completar tarefas     │
│ Exemplo          │ "Qual é o tempo?"     │ "Reserva um voo para  │
│                  │ → Resposta            │ Paris" → Executa      │
└──────────────────┴───────────────────────┴───────────────────────┘
                        

⚠️ Importante

A linha entre chatbots e agentes está a ficar cada vez mais ténue. Muitos chatbots modernos incorporam capacidades de agentes, como chamadas a APIs e memória de contexto.

🤝 Sistemas Multi-Agente

Sistemas multi-agente envolvem múltiplos agentes a trabalhar juntos para resolver problemas complexos. Cada agente pode ter uma especialização diferente.

Padrões de Colaboração

👨‍💼

Padrão Coordenador

Um agente principal delega tarefas a agentes especialistas e combina os resultados.

🔄

Padrão Pipeline

Agentes trabalham sequencialmente, onde o output de um é o input do próximo.

⚔️

Padrão Debate

Agentes com perspetivas diferentes discutem até chegar a um consenso.

👥

Padrão Equipa

Agentes com roles específicos (pesquisador, escritor, revisor) colaboram.

Exemplo com CrewAI

Python

from crewai import Agent, Task, Crew

# Criar agentes especializados
pesquisador = Agent(
    role='Pesquisador',
    goal='Pesquisar informações detalhadas sobre o tópico',
    backstory='Um pesquisador meticuloso que encontra informações precisas.',
    tools=[ferramenta_pesquisa_web]
)

escritor = Agent(
    role='Escritor',
    goal='Escrever conteúdo envolvente e informativo',
    backstory='Um escritor experiente que transforma dados em narrativas.',
    tools=[ferramenta_escrita]
)

revisor = Agent(
    role='Revisor',
    goal='Rever e melhorar a qualidade do conteúdo',
    backstory='Um editor rigoroso que garante qualidade.',
    tools=[ferramenta_gramatica]
)

# Criar tarefas
tarefa_pesquisa = Task(
    description='Pesquisar sobre {topico}',
    agent=pesquisador
)

tarefa_escrita = Task(
    description='Escrever um artigo sobre {topico}',
    agent=escritor
)

tarefa_revisao = Task(
    description='Rever e melhorar o artigo',
    agent=revisor
)

# Criar equipa
equipa = Crew(
    agents=[pesquisador, escritor, revisor],
    tasks=[tarefa_pesquisa, tarefa_escrita, tarefa_revisao],
    process=Process.sequential
)

# Executar
resultado = equipa.kickoff()

💡 Quando Usar Multi-Agente?

Tarefas que requerem diferentes especializações
Problemas complexos que beneficiam de múltiplas perspetivas
Workflows com etapas sequenciais bem definidas
Quando precisas de validação cruzada de resultados