Como Construir um Agente de IA do Zero: Guia Completo (Parte 2)

Você já imaginou criar seu próprio assistente de IA capaz de tomar decisões inteligentes e executar tarefas específicas? Neste guia prático, vou mostrar exatamente como construir um agente de IA funcional usando Python, mesmo que você não seja um especialista em inteligência artificial.

O que é um Agente de IA e Por Que Você Deveria Se Importar

Um agente de IA não é apenas mais um algoritmo – é uma entidade autônoma projetada para perceber seu ambiente, tomar decisões independentes e executar ações para atingir objetivos específicos. Diferente de sistemas de IA tradicionais, os agentes possuem capacidade de agir por conta própria.

Existem diferentes tipos de agentes que você pode implementar:

• Agentes reativos: respondem diretamente a mudanças ambientais sem memória interna
• Agentes baseados em modelos: utilizam representações internas do mundo para tomar decisões
• Agentes baseados em objetivos: planejam ações estratégicas para alcançar metas específicas

No mundo real, esses agentes já estão em toda parte – desde os chatbots que você usa diariamente até sistemas de recomendação sofisticados e até mesmo veículos autônomos.

Para construir um agente funcional, precisamos de quatro componentes essenciais:

1. Modelos: responsáveis pelo processamento de entrada e geração de respostas
2. Ferramentas: funções pré-definidas que executam tarefas específicas
3. Caixa de ferramentas: coleção organizada de todas as ferramentas disponíveis
4. Prompt do sistema: instruções claras que orientam como o agente deve processar a entrada do usuário

Preparando o Ambiente: Pré-requisitos para Implementação

Antes de começarmos a codificar, precisamos configurar nosso ambiente de desenvolvimento. Aqui está o que você vai precisar:

• Python 3.8 ou superior
• Um ambiente virtual para isolar suas dependências
• As seguintes bibliotecas: requests, json, termcolor e python-dotenv

Para instalar todas as dependências de uma vez, crie um arquivo requirements.txt e execute:

pip install -r requirements.txt

Além disso, precisaremos do Ollama, uma ferramenta poderosa para executar modelos de linguagem localmente. Você pode baixá-lo diretamente do site oficial.

Após instalar o Ollama, você precisará de um modelo de linguagem. Recomendo começar com o Mistral ou Llama2, que podem ser instalados com um simples comando:

ollama pull mistral

Construindo a Classe OllamaModel: O Cérebro do Seu Agente

A primeira parte do nosso agente é a classe que se comunica com o modelo de linguagem. Esta classe será responsável por enviar prompts e receber respostas.

class OllamaModel:
    def __init__(self, model_name, system_prompt="", temperature=0.7, stop=None):
        self.model_name = model_name
        self.system_prompt = system_prompt
        self.temperature = temperature
        self.stop = stop if stop else []
        self.url = "http://localhost:11434/api/generate"

    def generate_text(self, prompt):
        payload = {
            "model": self.model_name,
            "prompt": prompt,
            "system": self.system_prompt,
            "temperature": self.temperature,
            "stop": self.stop
        }
        
        try:
            response = requests.post(self.url, json=payload)
            response.raise_for_status()
            return response.text
        except requests.exceptions.RequestException as e:
            print(f"Error making request: {e}")
            return None

Esta classe interage com a API local do Ollama através da URL http://localhost:11434/api/generate. O método generate_text envia uma requisição com o prompt e retorna a resposta gerada pelo modelo.

Criando Ferramentas Poderosas para Seu Agente

As ferramentas são o que permitem que seu agente execute tarefas específicas. Vamos implementar duas ferramentas básicas:

def basic_calculator(input_str):
    """ Perform a numeric operation on two numbers based on the input string or dictionary. """
    try:
        if isinstance(input_str, dict):
            num1 = input_str.get("num1")
            num2 = input_str.get("num2")
            operation = input_str.get("operation")
        else:
            # Parse the input string
            parts = input_str.split()
            num1 = float(parts[0])
            operation = parts[1].lower()
            num2 = float(parts[2])
            
        if operation == "add" or operation == "+":
            return num1 + num2
        elif operation == "subtract" or operation == "-":
            return num1 - num2
        elif operation == "multiply" or operation == "*":
            return num1 * num2
        elif operation == "divide" or operation == "/":
            if num2 == 0:
                return "Error: Division by zero"
            return num1 / num2
        else:
            return f"Error: Unknown operation '{operation}'"
    except Exception as e:
        return f"Error: {str(e)}"

def reverse_string(input_string):
    """ Reverse the given string. """
    try:
        if isinstance(input_string, dict) and "text" in input_string:
            input_string = input_string["text"]
        return input_string[::-1]
    except Exception as e:
        return f"Error: {str(e)}"

A primeira ferramenta, basic_calculator, permite que o agente realize operações matemáticas básicas. A segunda, reverse_string, inverte qualquer texto fornecido. Ambas incluem tratamento de erros para garantir robustez.

Organizando as Ferramentas: A Classe ToolBox

Para que o agente possa acessar e entender as ferramentas disponíveis, precisamos de uma forma de armazená-las e descrevê-las:

class ToolBox:
    def __init__(self):
        self.tools = {}
        
    def store(self, name, function):
        self.tools[name] = {
            "function": function,
            "description": function.__doc__
        }
        
    def tools_str(self):
        result = "Available tools:\n"
        for name, tool in self.tools.items():
            result += f"- {name}: {tool['description']}\n"
        return result

A classe ToolBox mantém um dicionário de ferramentas, cada uma com sua função e descrição. O método tools_str fornece uma representação textual de todas as ferramentas disponíveis, que será usada pelo modelo para entender o que cada ferramenta faz.

A Peça Central: Criando a Classe Agente

Agora, vamos juntar tudo em nossa classe Agent:

class Agent:
    def __init__(self, model_service, tools=None):
        self.model_service = model_service
        self.toolbox = ToolBox()
        
        if tools:
            for name, function in tools.items():
                self.toolbox.store(name, function)
                
        self.system_prompt = self.prepare_tools()
        
    def prepare_tools(self):
        return f"""You are a helpful AI assistant that can use tools to help the user.
        
{self.toolbox.tools_str()}

When you need to use a tool, respond with a JSON object with the following structure:
{{
    "tool_choice": "tool_name", // The name of the tool to use, or "no tool" if no tool is needed
    "tool_input": ... // The input to the tool, can be a string or a JSON object
}}

For example:
Input: "Calculate 15 plus 7"
Output: {{"tool_choice": "basic_calculator", "tool_input": {{"num1": 15, "num2": 7, "operation": "add"}}}}

Input: "Reverse of 'Howwwww'?"
Output: {{"tool_choice": "reverse_string", "tool_input": "Howwwww"}}

Input: "Who are you?"
Output: {{"tool_choice": "no tool", "tool_input": "I am an AI assistant that can help you with calculations, reverse text, and answer questions. I can perform mathematical operations and reverse strings. How can I help you today?"}}
"""
    
    def think(self, user_input):
        prompt = f"User: {user_input}\nAssistant:"
        response = self.model_service.generate_text(prompt)
        return response
    
    def work(self, user_input):
        response = self.think(user_input)
        
        try:
            tool_response = json.loads(response)
            tool_choice = tool_response.get("tool_choice")
            tool_input = tool_response.get("tool_input")
            
            if tool_choice == "no tool":
                return tool_input
            
            if tool_choice in self.toolbox.tools:
                tool = self.toolbox.tools[tool_choice]["function"]
                result = tool(tool_input)
                return f"I used the {tool_choice} tool.\nResult: {result}"
            else:
                return f"I don't have access to the tool: {tool_choice}. Here's what I can do instead: {response}"
        except json.JSONDecodeError:
            return response
        except Exception as e:
            return f"Error processing response: {str(e)}\nOriginal response: {response}"

A classe Agent tem três métodos principais:

1. prepare_tools: cria um prompt do sistema detalhado que explica as ferramentas disponíveis
2. think: envia a entrada do usuário para o modelo e obtém uma resposta
3. work: processa a resposta do modelo, identificando qual ferramenta usar (se alguma) e executando-a

O prompt do sistema inclui exemplos claros de como o modelo deve formatar suas respostas, facilitando o processamento pelo agente.

Colocando Tudo em Prática: Executando o Agente

Finalmente, vamos ver como inicializar e executar nosso agente:

if __name__ == "__main__":
    # Initialize the model service
    model_service = OllamaModel(model_name="llama2", temperature=0.7)
    
    # Define the tools
    tools = {
        "basic_calculator": basic_calculator,
        "reverse_string": reverse_string
    }
    
    # Initialize the agent
    agent = Agent(model_service, tools)
    
    # Start the conversation
    print("Agent initialized. Type 'exit' to end the conversation.")
    
    while True:
        user_input = input("\nYou: ")
        
        if user_input.lower() == "exit":
            print("Goodbye!")
            break
            
        response = agent.work(user_input)
        print(f"\nAgent: {response}")

Este código inicializa o agente com nossas duas ferramentas e o serviço de modelo, e então entra em um loop para receber entradas do usuário e gerar respostas.

Veja alguns exemplos de interações:

Exemplo 1:

You: Calculate 15 plus 7
Agent: I used the basic_calculator tool.
Result: 22.0

Exemplo 2:

You: Reverse of 'Howwwww'?
Agent: I used the reverse_string tool.
Result: wwwwoH

Exemplo 3:

You: How are you?
Agent: I'm functioning well, thank you for asking! I'm here to help you with calculations, text reversal, or answer any questions you might have.

Conclusão: O Futuro dos Agentes de IA

Neste tutorial, construímos um agente de IA funcional capaz de entender a entrada do usuário, escolher a ferramenta apropriada e executar tarefas específicas. Embora este seja um exemplo relativamente simples, ele estabelece os fundamentos para criar agentes mais sofisticados.

Os componentes que desenvolvemos – modelo, ferramentas, caixa de ferramentas e prompt do sistema – trabalham em harmonia para criar uma experiência de usuário fluida e inteligente. O prompt do sistema, em particular, é crucial para orientar o comportamento do agente.

As possibilidades para expandir este agente são praticamente ilimitadas. Você pode:

• Adicionar mais ferramentas para aumentar as capacidades do agente
• Implementar memória para que o agente lembre de conversas anteriores
• Integrar APIs externas para acessar dados em tempo real
• Adicionar capacidade de aprendizado para que o agente melhore com o tempo

À medida que os modelos de linguagem continuam a evoluir, os agentes de IA se tornarão cada vez mais poderosos e versáteis, transformando a maneira como interagimos com a tecnologia.

Experimente modificar o código, adicionar suas próprias ferramentas e ver o que seu agente pode fazer. O futuro da IA está nas mãos de criadores como você!

Fonte: Vipra Singh. “AI Agents: Build an Agent from Scratch (Part 2)”. Disponível em: https://medium.com/@vipra_singh/ai-agents-build-an-agent-from-scratch-part-2-7ae11840c93a.