Construir um Agente de IA em Funcionamento: Um Glossário Prático

Um agente de IA é um programa que recebe um objetivo, decide em uma sequência de ações, e executa essas ações usando ferramentas até que o objetivo seja alcançado ou desista. Isso é diferente de um chatbot, que apenas responde a mensagens. Um agente planeja, chama funções, verifica resultados e se ajusta. Se você só usou ChatGPT através de um navegador, construir seu primeiro agente é onde o modelo deixa de ser um gerador de texto e passa a ser um componente em um sistema maior.

O loop principal

Cada agente, não importa como seja comercializado, executa alguma versão do mesmo loop: observar, pensar, agir, repetir. Concretamente:

1. O agente recebe uma tarefa ("encontre o voo mais barato para Lisboa no próximo mês e rascunhe um resumo por email").
2. Ele chama o LLM com a tarefa mais uma descrição das ferramentas disponíveis.
3. O modelo retorna uma resposta final ou uma chamada de ferramenta, como search_flights(destination="Lisbon", month="2025-06").
4. Seu código executa essa função, obtém um resultado real e o alimenta de volta no contexto do modelo.
5. O modelo decide o que fazer a seguir: chamar outra ferramenta, pedir esclarecimento ou terminar.

Esse padrão é frequentemente chamado de loop ReAct (reason plus act), e é a base de frameworks como executores de agentes do LangChain, agentes do LlamaIndex e API de function-calling do OpenAI. Você pode implementar tudo isso em menos de 100 linhas de Python com apenas uma API de LLM e um while loop — os frameworks adicionam conveniência, não magia.

Ferramentas são o que o tornam um agente

Um modelo sem ferramentas só pode falar. Dê-lhe funções e ele pode agir. Ferramentas são tipicamente funções Python simples envolvidas com um schema descrevendo seu nome, parâmetros e propósito, para que o modelo saiba quando e como chamá-las. Exemplo:

def get_weather(city: str) -> str:
    """Return current weather for a given city."""
    resp = requests.get(f"https://api.weather.example/v1/{city}")
    return resp.json()["summary"]

Com o function-calling do OpenAI, você passa um schema JSON ao lado dessa função, e o modelo retorna uma chamada estruturada como {"name": "get_weather", "arguments": {"city": "Lisbon"}} em vez de texto livre. Seu código analisa isso, executa a função real e retorna o resultado como uma nova mensagem na conversa. Repita até que o modelo tenha informação suficiente para responder.

Memória e estado

Uma única chamada de API não tem memória além de sua janela de contexto. Agentes precisam de estado explícito: uma lista em execução de mensagens (o histórico da conversa), e frequentemente um armazenamento separado para fatos de mais longo prazo. Para tarefas curtas, uma lista Python de dicts representando a conversa é suficiente. Para agentes que precisam lembrar coisas entre sessões, você recorrerá a um banco de dados vetorial (Chroma, Pinecone, Qdrant) para armazenar e recuperar informações passadas relevantes através de embeddings.

Não sobre-engenhare isso cedo. Um número surpreendente de projetos "agente" falha não porque o LLM é fraco mas porque o gerenciamento de estado é descuidado: mensagens duplicadas, crescimento de contexto ilimitado, ou perder o controle de qual chamada de ferramenta pertence a qual resultado.

Um exemplo mínimo em funcionamento

Aqui está a forma de um agente minimalista usando a API do OpenAI, sem framework:

messages = [{"role": "user", "content": "What's the weather in Lisbon?"}]

while True:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=[weather_tool_schema],
    )
    msg = response.choices[0].message
    if msg.tool_calls:
        for call in msg.tool_calls:
            result = get_weather(**json.loads(call.function.arguments))
            messages.append(msg)
            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": result,
            })
    else:
        print(msg.content)
        break

Esse é um agente real e em funcionamento. Tudo mais — estratégias de planejamento, coordenação multi-agente, pipelines de recuperação — se constrói nesse loop.

Onde falha

Agentes falham de formas previsíveis: loops infinitos de chamadas de ferramentas quando o modelo não consegue dizer que teve sucesso, argumentos de função alucinados, e custos descontrolados ao chamar ferramentas caras novamente. Proteja contra loops com um limite de iteração rígido (digamos, 10 passos) e registre cada chamada de ferramenta durante desenvolvimento. Valide argumentos antes de executar qualquer coisa que toque em um sistema real — um agente que pode enviar emails ou executar comandos shell precisa da mesma sanitização de entrada que você aplicaria ao código voltado para o usuário, porque o LLM é, na verdade, um usuário não confiável gerando essa entrada.

Para onde ir a seguir

Uma vez que o loop funciona, os problemas interessantes começam: escolher entre designs single-agent e multi-agent, decidir quanto de autonomia conceder, e testar agentes de forma confiável quando seu output não é determinístico. As trilhas de IA e Python da Korra Studio cobrem retrieval-augmented generation, design de prompts e padrões de tool-calling em mais profundidade se você quiser continuar construindo a partir daqui.