Índice

Autor: GPT4o

Construindo um Agente de IA do Zero em Python

O que é um Agente de IA?

Um agente de IA é uma entidade autônoma que percebe seu ambiente, toma decisões e executa ações para atingir objetivos específicos. Existem diferentes tipos de agentes, desde os reativos até aqueles baseados em modelos, metas e utilidade, cada um com diferentes níveis de complexidade e capacidade de aprendizado. Aqui está um breve resumo:

Agentes Reativos: Respondem diretamente às mudanças no ambiente sem memória interna.
Agentes Baseados em Modelos: Utilizam modelos internos do mundo para tomar decisões.
Agentes Baseados em Metas: Planejam ações com base em objetivos específicos a serem alcançados.
Agentes Baseados em Utilidade: Avaliam ações baseadas em uma função de utilidade para maximizar os resultados.

Principais Itens:

Agentes reativos respondem diretamente a mudanças ambientais sem memória interna.
Agentes baseados em modelos usam modelos internos do mundo para tomar decisões.
A complexidade varia de agentes simples a agentes inteligentes que aprendem e se adaptam.

Pré-requisitos para a Implementação

Antes de construir o agente, é necessário configurar o ambiente Python. Siga estas etapas:

Configuração do Ambiente Python

Instalar Python (3.8+ recomendado):
- Baixe e instale Python.
- Verifique a instalação executando python --version.

Criar um Ambiente Virtual:

python -m venv ai_agents_env
source ai_agents_env/bin/activate  # No Windows: ai_agents_env\Scripts\activate

Instalar as Dependências:
- Navegue para o diretório do repositório e execute:
  sh pip install -r requirements.txt

Configurar o Ollama Localmente

O Ollama gerencia modelos de linguagem localmente. Siga estas etapas para instalar e configurar:

Baixar e Instalar Ollama:
- Visite o site oficial do Ollama e baixe o instalador para o seu sistema operacional.
Verificar a instalação do Ollama:
```
ollama --version
```

Puxar um Modelo (se necessário):

ollama pull mistral  # Substitua 'mistral' pelo modelo necessário

Etapas da Implementação: Definindo Classes e Funções

Definindo a Classe do Modelo

Vamos criar a classe OllamaModel para interagir com a API local e gerar respostas.

from termcolor import colored
import os
from dotenv import load_dotenv
load_dotenv()
import requests
import json
import operator

class OllamaModel:
    def __init__(self, model, system_prompt, temperature=0, stop=None):
        self.model_endpoint = "http://localhost:11434/api/generate"
        self.temperature = temperature
        self.model = model
        self.system_prompt = system_prompt
        self.headers = {"Content-Type": "application/json"}
        self.stop = stop

    def generate_text(self, prompt):
        payload = {
            "model": self.model,
            "format": "json",
            "prompt": prompt,
            "system": self.system_prompt,
            "stream": False,
            "temperature": self.temperature,
            "stop": self.stop
        }

        try:
            request_response = requests.post(
                self.model_endpoint,
                headers=self.headers,
                data=json.dumps(payload)
            )

            response = request_response.json()['response']
            response_dict = json.loads(response)
            return response_dict
        except requests.RequestException as e:
            return {"error": f"Error in invoking model! {str(e)}"}

Criando Ferramentas para o Agente

Vamos criar funções simples que o agente poderá usar, como uma calculadora básica e um reversor de strings.

def basic_calculator(input_str):
    try:
        if isinstance(input_str, dict):
            input_dict = input_str
        else:
            input_str_clean = input_str.replace("'", "\"").strip().strip("\"")
            input_dict = json.loads(input_str_clean)

        if not all(key in input_dict for key in ['num1', 'num2', 'operation']):
            return "Error: Input must contain 'num1', 'num2', and 'operation'"

        num1 = float(input_dict['num1'])
        num2 = float(input_dict['num2'])
        operation = input_dict['operation'].lower()
    except (json.JSONDecodeError, KeyError, ValueError) as e:
        return "Invalid input format. Please provide valid numbers and operation."

    operations = {
        'add': operator.add,
        'plus': operator.add,
        'subtract': operator.sub,
        'minus': operator.sub,
        'multiply': operator.mul,
        'times': operator.mul,
        'divide': operator.truediv,
        'floor_divide': operator.floordiv,
        'modulus': operator.mod,
        'power': operator.pow,
        'lt': operator.lt,
        'le': operator.le,
        'eq': operator.eq,
        'ne': operator.ne,
        'ge': operator.ge,
        'gt': operator.gt
    }

    if operation not in operations:
        return f"Unsupported operation: '{operation}'. Supported operations are: {', '.join(operations.keys())}"

    try:
        if (operation in ['divide', 'floor_divide', 'modulus']) and num2 == 0:
            return "Error: Division by zero is not allowed"
        result = operations[operation](num1, num2)
        return f"The answer is: {result:.6f}".rstrip('0').rstrip('.') if isinstance(result, float) else str(result)
    except Exception as e:
        return f"Error during calculation: {str(e)}"

def reverse_string(input_string):
    if not isinstance(input_string, str):
        return "Error: Input must be a string"
    return f"The reversed string is: {input_string[::-1]}"

Construindo a Caixa de Ferramentas

Vamos criar a classe ToolBox para armazenar e descrever as ferramentas.

class ToolBox:
    def __init__(self):
        self.tools_dict = {}

    def store(self, functions_list):
        for func in functions_list:
            self.tools_dict[func.__name__] = func.__doc__
        return self.tools_dict

    def tools(self):
        tools_str = ""
        for name, doc in self.tools_dict.items():
            tools_str += f"{name}: \"{doc}\"\n"
        return tools_str.strip()

Criando a Classe do Agente

Vamos criar a classe Agent que decidirá qual ferramenta usar com base na entrada do usuário e executará as ações.

agent_system_prompt_template = """
You are an intelligent AI assistant with access to specific tools. Your responses must ALWAYS be in this JSON format:
{{
    "tool_choice": "name_of_the_tool",
    "tool_input": "inputs_to_the_tool"
}}

TOOLS AND WHEN TO USE THEM:
1. basic_calculator: Use for ANY mathematical calculations
   - Input format: {{"num1": number, "num2": number, "operation": "add/subtract/multiply/divide"}}
   ...
2. reverse_string: Use for ANY request involving reversing text
   ...
3. no tool: Use for general conversation and questions
   ...
STRICT RULES:
1. For questions about identity, capabilities, or feelings: ...
2. For ANY text reversal request: ...
3. For ANY math operations: ...
Here is a list of your tools along with their descriptions:
{tool_descriptions}
"""

class Agent:
    def __init__(self, tools, model_service, model_name, stop=None):
        self.tools = tools
        self.model_service = model_service
        self.model_name = model_name
        self.stop = stop

    def prepare_tools(self):
        toolbox = ToolBox()
        toolbox.store(self.tools)
        return toolbox.tools()

    def think(self, prompt):
        tool_descriptions = self.prepare_tools()
        agent_system_prompt = agent_system_prompt_template.format(tool_descriptions=tool_descriptions)
        model_instance = self.model_service(self.model_name, agent_system_prompt, 0, self.stop)
        return model_instance.generate_text(prompt)

    def work(self, prompt):
        agent_response_dict = self.think(prompt)
        tool_choice = agent_response_dict.get("tool_choice")
        tool_input = agent_response_dict.get("tool_input")
        for tool in self.tools:
            if tool.__name__ == tool_choice:
                response = tool(tool_input)
                print(colored(response, 'cyan'))
                return
        print(colored(tool_input, 'cyan'))
        return

Etapas da Implementação: Fluxo de Execução

O agente recebe uma solicitação do usuário (prompt), passa o prompt para o modelo (think), que escolhe a ferramenta adequada e seus inputs (tool_choice e tool_input). Então, o agente executa a ferramenta escolhida (work) e apresenta o resultado.

Principais Itens:

O método think usa o modelo para determinar a ferramenta e a entrada.
O método work executa a ferramenta selecionada.
A saída é formatada como um JSON com tool_choice e tool_input.

Executando o Agente e Considerações Finais

O código principal inicia o agente, aceita entrada do usuário e executa o ciclo de solicitação, processamento e resposta.

if __name__ == "__main__":
    tools = [basic_calculator, reverse_string]
    model_service = OllamaModel
    model_name = "llama2"
    stop = "<|eot_id|>"

    agent = Agent(tools=tools, model_service=model_service, model_name=model_name, stop=stop)

    print("Welcome to the AI Agent! Type 'exit' to quit.")
    while True:
        prompt = input("Ask me anything: ")
        if prompt.lower() == "exit":
            break
        agent.work(prompt)

Este projeto serve como base para a construção de agentes mais complexos e sofisticados, com maior capacidade de aprendizado e adaptação. A adição de mais ferramentas e a integração com diferentes modelos de linguagem podem expandir significativamente as funcionalidades do agente.

Conclusão

Este tutorial fornece um guia passo a passo para construir um agente de IA em Python, integrando modelos de linguagem e ferramentas customizadas. O agente demonstra a capacidade de processar a entrada do usuário, escolher ferramentas apropriadas e executar tarefas específicas.

A construção do agente demonstra a interação entre diferentes componentes: o modelo de linguagem (que processa a entrada do usuário e seleciona a ferramenta), as ferramentas (que realizam tarefas específicas) e a lógica do agente (que orquestra todo o processo). Este projeto pode ser a base para futuras aplicações em diversas áreas, incentivando a exploração de recursos de IA.

Fonte: VIPRA SINGH. “AI AGENTS: BUILD AN AGENT FROM SCRATCH (PART-2)”. Disponível em: link original.

Autor: Claude Sonnet

Construindo um Agente de IA do Zero em Python

Agent Building

O que é um Agente de IA?

Um agente de IA é uma entidade autônoma capaz de perceber seu ambiente, tomar decisões e executar ações para atingir objetivos específicos. Os agentes podem variar em complexidade, desde simples agentes reativos até agentes inteligentes mais avançados que aprendem e se adaptam ao longo do tempo.

Principais tipos de agentes:

Agentes Reativos: Respondem diretamente a mudanças ambientais sem memória interna
Agentes Baseados em Modelos: Utilizam modelos internos do mundo para tomar decisões
Agentes Baseados em Objetivos: Planejam ações com base em metas específicas
Agentes Baseados em Utilidade: Avaliam ações potenciais com base em uma função de utilidade

Pré-requisitos para Implementação

Antes de começar a construir o agente, você precisará:

1. Configurar o Ambiente Python

# Instalar Python 3.8+ 
python --version

# Criar ambiente virtual
python -m venv ai_agents_env
source ai_agents_env/bin/activate # Windows: ai_agents_env\Scripts\activate

# Instalar dependências 
pip install -r requirements.txt

2. Configurar o Ollama Localmente

Baixar e instalar o Ollama do site oficial
Verificar instalação: ollama --version
Baixar modelo se necessário: ollama pull mistral

Etapas da Implementação

Definindo Classes e Funções

1. Classe do Modelo (OllamaModel)

class OllamaModel:
    def __init__(self, model, system_prompt, temperature=0, stop=None):
        self.model_endpoint = "http://localhost:11434/api/generate"
        self.temperature = temperature
        self.model = model
        self.system_prompt = system_prompt
        self.headers = {"Content-Type": "application/json"}
        self.stop = stop

2. Ferramentas Básicas

def basic_calculator(input_str):
    """Realiza operações matemáticas básicas"""
    # Implementação da calculadora

def reverse_string(input_string): 
    """Inverte uma string fornecida"""
    # Implementação da inversão

Fluxo de Execução

Pensar (think): O agente recebe um prompt e decide qual ferramenta usar
Trabalhar (work): Executa a ferramenta escolhida com os parâmetros apropriados
Responder: Retorna o resultado formatado para o usuário

Executando o Agente

if __name__ == "__main__":
    tools = [basic_calculator, reverse_string]
    model_service = OllamaModel
    model_name = "llama2"
    agent = Agent(tools=tools, model_service=model_service, model_name=model_name)

    while True:
        prompt = input("Pergunte algo: ")
        if prompt.lower() == "exit":
            break
        agent.work(prompt)

Conclusão

Este tutorial demonstrou como construir um agente de IA básico mas funcional utilizando Python. O agente pode processar entradas do usuário, selecionar ferramentas apropriadas e executar tarefas específicas. Esta implementação serve como base para construir agentes mais complexos com capacidades expandidas.

Fonte: Vipra Singh. “AI Agents: Build an Agent from Scratch (Part-2)”. Disponível em: Medium

Autor: Gemini 2.0 Flash

Construindo um Agente de IA do Zero em Python: Um Guia Passo a Passo

Você já se perguntou como construir seu próprio agente de IA? Neste artigo, vamos explorar o passo a passo para criar um agente de IA em Python, desde a configuração do ambiente até a execução do agente.

Se você está buscando entender como a inteligência artificial pode ser aplicada na prática, este guia é para você. Vamos mergulhar no mundo dos agentes de IA e descobrir como eles podem automatizar tarefas e tomar decisões inteligentes.

O que é um Agente de IA?

Um agente de IA é uma entidade autônoma que percebe seu ambiente, toma decisões e executa ações para atingir objetivos específicos.

Existem diferentes tipos de agentes, cada um com suas próprias características:

Agentes reativos: Respondem diretamente a mudanças ambientais sem memória interna.
Agentes baseados em modelos: Usam modelos internos do mundo para tomar decisões.
Agentes baseados em objetivos: Planejam ações para atingir objetivos específicos.
Agentes baseados em utilidade: Avaliam ações com base em uma função de utilidade para maximizar resultados.

A complexidade de um agente pode variar bastante, desde agentes simples que reagem a estímulos até agentes inteligentes que aprendem e se adaptam ao longo do tempo.

Exemplos de agentes de IA incluem chatbots, sistemas de recomendação e veículos autônomos.

Os componentes principais do nosso agente são:

Modelos: O cérebro do agente, responsável por processar a entrada e gerar respostas.
Ferramentas: Funções pré-definidas que o agente pode executar com base na solicitação do usuário.
Caixa de ferramentas: Uma coleção de ferramentas que o agente tem à sua disposição.
Prompt do sistema: O conjunto de instruções que guia o agente sobre como lidar com a entrada do usuário e escolher as ferramentas certas.

Pré-requisitos para a Implementação

Antes de começarmos a construir nosso agente, precisamos configurar o ambiente Python.

Instale o Python:
- Baixe e instale o Python (versão 3.8 ou superior recomendada) do site oficial: python.org.
- Verifique a instalação abrindo o terminal e digitando: python --version
Crie um ambiente virtual:
- É recomendável usar um ambiente virtual para gerenciar as dependências do projeto.
- Crie um ambiente virtual com o seguinte comando: python -m venv ai_agents_env
- Ative o ambiente virtual:
  - No Linux/macOS: source ai_agents_env/bin/activate
  - No Windows: ai_agents_env\Scripts\activate
Instale as dependências:
- Navegue até o diretório do repositório e instale as dependências listadas no arquivo requirements.txt: pip install -r requirements.txt
Configure o Ollama localmente:
- O Ollama será usado para executar e gerenciar modelos de linguagem localmente.
- Visite o site oficial do Ollama: Ollama e baixe o instalador para o seu sistema operacional.
- Instale o Ollama seguindo as instruções para sua plataforma.
- Verifique a instalação executando o seguinte comando: ollama --version
- Se necessário, baixe um modelo específico usando: ollama pull mistral (substitua ‘mistral’ pelo modelo desejado).

Com o ambiente configurado, estamos prontos para começar a implementar nosso agente de IA.

Etapas da Implementação: Definindo Classes e Funções

A implementação do nosso agente envolve a criação de classes e funções que irão interagir entre si para realizar tarefas específicas.

Passo 1: Configurando o Ambiente

Além do Python, precisaremos instalar algumas bibliotecas essenciais: requests, json, termcolor e python-dotenv.

Execute o seguinte comando para instalar as bibliotecas:

pip install requests termcolor python-dotenv

Passo 2: Definindo a Classe do Modelo

A primeira coisa que precisamos é um modelo que processe a entrada do usuário. Criaremos uma classe OllamaModel que interage com a API local do Ollama para gerar respostas.

from termcolor import colored
import os
from dotenv import load_dotenv
load_dotenv()
### Models
import requests
import json
import operator

class OllamaModel:
    def __init__(self, model, system_prompt, temperature=0, stop=None):
        """
        Inicializa o OllamaModel com os parâmetros fornecidos.
        """
        self.model_endpoint = "http://localhost:11434/api/generate"
        self.temperature = temperature
        self.model = model
        self.system_prompt = system_prompt
        self.headers = {"Content-Type": "application/json"}
        self.stop = stop

    def generate_text(self, prompt):
        """
        Gera uma resposta do modelo Ollama com base no prompt fornecido.
        """
        payload = {
            "model": self.model,
            "format": "json",
            "prompt": prompt,
            "system": self.system_prompt,
            "stream": False,
            "temperature": self.temperature,
            "stop": self.stop
        }

        try:
            request_response = requests.post(
                self.model_endpoint, 
                headers=self.headers, 
                data=json.dumps(payload)
            )

            print("REQUEST RESPONSE", request_response)
            request_response_json = request_response.json()
            response = request_response_json['response']
            response_dict = json.loads(response)

            print(f"\n\nResponse from Ollama model: {response_dict}")

            return response_dict
        except requests.RequestException as e:
            response = {"error": f"Erro ao invocar o modelo! {str(e)}"}
            return response

Passo 3: Criando Ferramentas para o Agente

O próximo passo é criar ferramentas que nossos agentes possam usar. Essas ferramentas são funções Python simples que executam tarefas específicas. Aqui está um exemplo de uma calculadora básica e um inversor de strings:

def basic_calculator(input_str):
    """
    Realiza uma operação numérica em dois números com base na string ou dicionário de entrada.
    """
    try:
        # Lida com entradas de dicionário e string
        if isinstance(input_str, dict):
            input_dict = input_str
        else:
            # Limpa e analisa a string de entrada
            input_str_clean = input_str.replace("'", "\"")
            input_str_clean = input_str_clean.strip().strip("\"")
            input_dict = json.loads(input_str_clean)

        # Valida os campos obrigatórios
        if not all(key in input_dict for key in ['num1', 'num2', 'operation']):
            return "Erro: A entrada deve conter 'num1', 'num2' e 'operation'"

        num1 = float(input_dict['num1'])  # Converte para float para lidar com números decimais
        num2 = float(input_dict['num2'])
        operation = input_dict['operation'].lower()  # Torna insensível a maiúsculas e minúsculas
    except (json.JSONDecodeError, KeyError) as e:
        return "Formato de entrada inválido. Forneça números e operação válidos."
    except ValueError as e:
        return "Erro: Forneça valores numéricos válidos."

    # Define as operações suportadas com tratamento de erros
    operations = {
        'add': operator.add,
        'plus': operator.add,  # Palavra alternativa para add
        'subtract': operator.sub,
        'minus': operator.sub,  # Palavra alternativa para subtract
        'multiply': operator.mul,
        'times': operator.mul,  # Palavra alternativa para multiply
        'divide': operator.truediv,
        'floor_divide': operator.floordiv,
        'modulus': operator.mod,
        'power': operator.pow,
        'lt': operator.lt,
        'le': operator.le,
        'eq': operator.eq,
        'ne': operator.ne,
        'ge': operator.ge,
        'gt': operator.gt
    }

    # Verifica se a operação é suportada
    if operation not in operations:
        return f"Operação não suportada: '{operation}'. As operações suportadas são: {', '.join(operations.keys())}"

    try:
        # Tratamento especial para divisão por zero
        if (operation in ['divide', 'floor_divide', 'modulus']) and num2 == 0:
            return "Erro: A divisão por zero não é permitida"

        # Realiza a operação
        result = operations[operation](num1, num2)

        # Formata o resultado com base no tipo
        if isinstance(result, bool):
            result_str = "True" if result else "False"
        elif isinstance(result, float):
            # Lida com a precisão de ponto flutuante
            result_str = f"{result:.6f}".rstrip('0').rstrip('.')
        else:
            result_str = str(result)

        return f"A resposta é: {result_str}"
    except Exception as e:
        return f"Erro durante o cálculo: {str(e)}"

def reverse_string(input_string):
    """
    Inverte a string fornecida.
    """
    # Verifica se a entrada é uma string
    if not isinstance(input_string, str):
        return "Erro: A entrada deve ser uma string"

    # Inverte a string usando slicing
    reversed_string = input_string[::-1]

    # Formata a saída
    result = f"A string invertida é: {reversed_string}"

    return result

Passo 4: Construindo a Caixa de Ferramentas

A classe ToolBox armazena todas as ferramentas que o agente pode usar e fornece descrições para cada uma:

class ToolBox:
    def __init__(self):
        self.tools_dict = {}

    def store(self, functions_list):
        """
        Armazena o nome literal e a docstring de cada função na lista.
        """
        for func in functions_list:
            self.tools_dict[func.__name__] = func.__doc__
        return self.tools_dict

    def tools(self):
        """
        Retorna o dicionário criado em store como uma string de texto.
        """
        tools_str = ""
        for name, doc in self.tools_dict.items():
            tools_str += f"{name}: \"{doc}\"\n"
        return tools_str.strip()

Passo 5: Criando a Classe Agente

O agente precisa pensar, decidir qual ferramenta usar e executá-la. Aqui está a classe Agent:

agent_system_prompt_template = """
Você é um assistente de IA inteligente com acesso a ferramentas específicas. Suas respostas SEMPRE devem estar neste formato JSON:
{{
    "tool_choice": "nome_da_ferramenta",
    "tool_input": "entradas_para_a_ferramenta"
}}

FERRAMENTAS E QUANDO USÁ-LAS:

1. basic_calculator: Use para QUALQUER cálculo matemático
   - Formato de entrada: {{"num1": number, "num2": number, "operation": "add/subtract/multiply/divide"}}
   - Operações suportadas: add/plus, subtract/minus, multiply/times, divide
   - Exemplos de entradas e saídas:
     Entrada: "Calcule 15 mais 7"
     Saída: {{"tool_choice": "basic_calculator", "tool_input": {{"num1": 15, "num2": 7, "operation": "add"}}}}

     Entrada: "Quanto é 100 dividido por 5?"
     Saída: {{"tool_choice": "basic_calculator", "tool_input": {{"num1": 100, "num2": 5, "operation": "divide"}}}}

2. reverse_string: Use para QUALQUER solicitação envolvendo inversão de texto
   - Formato de entrada: Apenas o texto a ser invertido como uma string
   - SEMPRE use esta ferramenta quando o usuário mencionar "inverter", "ao contrário" ou pedir para inverter o texto
   - Exemplos de entradas e saídas:
     Entrada: "Inverso de 'Howwwww'?"
     Saída: {{"tool_choice": "reverse_string", "tool_input": "Howwwww"}}

     Entrada: "Qual é o inverso de Python?"
     Saída: {{"tool_choice": "reverse_string", "tool_input": "Python"}}

3. no tool: Use para conversas e perguntas gerais
   - Exemplos de entradas e saídas:
     Entrada: "Quem é você?"
     Saída: {{"tool_choice": "no tool", "tool_input": "Eu sou um assistente de IA que pode ajudá-lo com cálculos, inverter texto e responder a perguntas. Posso realizar operações matemáticas e inverter strings. Como posso ajudá-lo hoje?"}}

     Entrada: "Como você está?"
     Saída: {{"tool_choice": "no tool", "tool_input": "Estou funcionando bem, obrigado por perguntar! Estou aqui para ajudá-lo com cálculos, inversão de texto ou responder a quaisquer perguntas que você possa ter."}}

REGRAS ESTRICTAS:
1. Para perguntas sobre identidade, capacidades ou sentimentos:
   - SEMPRE use "no tool"
   - Forneça uma resposta completa e amigável
   - Mencione suas capacidades

2. Para QUALQUER solicitação de inversão de texto:
   - SEMPRE use "reverse_string"
   - Extraia APENAS o texto a ser invertido
   - Remova aspas, "inverso de" e outros textos extras

3. Para QUALQUER operação matemática:
   - SEMPRE use "basic_calculator"
   - Extraia os números e a operação
   - Converta números de texto em dígitos

Aqui está uma lista de suas ferramentas junto com suas descrições:
{tool_descriptions}

Lembre-se: Sua resposta SEMPRE deve ser um JSON válido com campos "tool_choice" e "tool_input".
"""

class Agent:
    def __init__(self, tools, model_service, model_name, stop=None):
        """
        Inicializa o agente com uma lista de ferramentas e um modelo.
        """
        self.tools = tools
        self.model_service = model_service
        self.model_name = model_name
        self.stop = stop

    def prepare_tools(self):
        """
        Armazena as ferramentas na caixa de ferramentas e retorna suas descrições.
        """
        toolbox = ToolBox()
        toolbox.store(self.tools)
        tool_descriptions = toolbox.tools()
        return tool_descriptions

    def think(self, prompt):
        """
        Executa o método generate_text no modelo usando o modelo de prompt do sistema e as descrições das ferramentas.
        """
        tool_descriptions = self.prepare_tools()
        agent_system_prompt = agent_system_prompt_template.format(tool_descriptions=tool_descriptions)

        # Cria uma instância do serviço de modelo com o prompt do sistema

        if self.model_service == OllamaModel:
            model_instance = self.model_service(
                model=self.model_name,
                system_prompt=agent_system_prompt,
                temperature=0,
                stop=self.stop
            )
        else:
            model_instance = self.model_service(
                model=self.model_name,
                system_prompt=agent_system_prompt,
                temperature=0
            )

        # Gera e retorna o dicionário de resposta
        agent_response_dict = model_instance.generate_text(prompt)
        return agent_response_dict

    def work(self, prompt):
        """
        Analisa o dicionário retornado de think e executa a ferramenta apropriada.
        """
        agent_response_dict = self.think(prompt)
        tool_choice = agent_response_dict.get("tool_choice")
        tool_input = agent_response_dict.get("tool_input")

        for tool in self.tools:
            if tool.__name__ == tool_choice:
                response = tool(tool_input)
                print(colored(response, 'cyan'))
                return

        print(colored(tool_input, 'cyan'))
        return

Passo 6: Executando o Agente

Finalmente, vamos juntar tudo e executar nosso agente. Na seção principal do seu script, inicialize o agente e comece a aceitar a entrada do usuário:

# Exemplo de uso
if __name__ == "__main__":
    """
    Instruções para usar este agente:

    Exemplos de consultas que você pode tentar:
    1. Operações de calculadora:
       - "Calcule 15 mais 7"
       - "Quanto é 100 dividido por 5?"
       - "Multiplique 23 e 4"

    2. Inversão de string:
       - "Inverta a palavra 'hello world'"
       - "Você pode inverter 'Python Programming'?"

    3. Perguntas gerais (obterá respostas diretas):
       - "Quem é você?"
       - "Com o que você pode me ajudar?"

    Comandos Ollama (execute-os no terminal):
    - Verifique os modelos disponíveis:    'ollama list'
    - Verifique os modelos em execução:      'ps aux | grep ollama'
    - Liste as tags do modelo:          'curl http://localhost:11434/api/tags'
    - Puxe um novo modelo:         'ollama pull mistral'
    - Execute o servidor de modelo:         'ollama serve'
    """

    tools = [basic_calculator, reverse_string]

    # Descomente abaixo para executar com OpenAI
    # model_service = OpenAIModel
    # model_name = 'gpt-3.5-turbo'
    # stop = None

    # Usando Ollama com modelo llama2
    model_service = OllamaModel
    model_name = "llama2"  # Pode ser alterado para outros modelos como 'mistral', 'codellama', etc.
    stop = "<|eot_id|>"

    agent = Agent(tools=tools, model_service=model_service, model_name=model_name, stop=stop)

    print("\nBem-vindo ao Agente de IA! Digite 'exit' para sair.")
    print("Você pode me pedir para:")
    print("1. Realizar cálculos (por exemplo, 'Calcule 15 mais 7')")
    print("2. Inverter strings (por exemplo, 'Inverta hello world')")
    print("3. Responder a perguntas gerais\n")

    while True:
        prompt = input("Pergunte-me qualquer coisa: ")
        if prompt.lower() == "exit":
            break

        agent.work(prompt)

Executando o Agente e Considerações Finais

Com todas as peças no lugar, você pode executar o script e interagir com seu agente de IA.

O agente irá receber a entrada do usuário, processá-la, escolher a ferramenta apropriada e executar a tarefa solicitada.

Este projeto serve como base para a construção de agentes mais complexos e sofisticados, com maior capacidade de aprendizado e adaptação.

A adição de mais ferramentas e a integração com diferentes modelos de linguagem podem expandir significativamente as funcionalidades do agente.

Conclusão

Neste tutorial, você aprendeu como construir um agente de IA do zero em Python.

Este guia fornece um guia passo a passo para construir um agente de IA em Python, integrando modelos de linguagem e ferramentas customizadas. O agente demonstra a capacidade de processar a entrada do usuário, escolher ferramentas apropriadas e executar tarefas específicas.

Aproveite este conhecimento para explorar novas possibilidades e construir agentes de IA ainda mais poderosos e inteligentes.

Autor: Grok 2

Construindo um Agente de IA do Zero em Python: Um Guia Completo

Você já se perguntou como criar um agente de inteligência artificial capaz de tomar decisões e executar tarefas específicas? Se sim, está no lugar certo! Neste artigo, vamos explorar como construir um agente de IA do zero, utilizando Python. Vamos mostrar como você pode criar um sistema que não apenas entende o seu comando, mas também age de forma autônoma para resolver seus problemas. Pronto para transformar sua curiosidade em ação? Vamos começar!

O que é um Agente de IA?

Um agente de IA é uma entidade autônoma que percebe seu ambiente, toma decisões e executa ações para atingir objetivos específicos. Existem diferentes tipos de agentes, cada um com seu nível de complexidade e capacidade de aprendizado.

Agentes reativos respondem diretamente a mudanças ambientais sem memória interna.
Agentes baseados em modelos usam modelos internos do mundo para tomar decisões.
A complexidade varia de agentes simples a agentes inteligentes que aprendem e se adaptam.

Pré-requisitos para a Implementação

Antes de começarmos a construir o agente, é essencial configurar o ambiente de desenvolvimento adequado. Aqui estão os passos necessários:

Instalar Python e verificar a versão: python --version.
Criar um ambiente virtual: python -m venv ai_agents_env.
Instalar dependências: pip install -r requirements.txt.
Instalar e configurar o Ollama localmente para gerenciar modelos de linguagem.

Etapas da Implementação: Definindo Classes e Funções

A construção do agente envolve a criação de classes e funções essenciais. Vamos detalhar como fazer isso:

Classe OllamaModel: Gerencia a comunicação com o modelo de linguagem, permitindo que o agente processe solicitações e gere respostas.
Funções de ferramentas como basic_calculator e reverse_string realizam cálculos e invertem strings, respectivamente.
Classe Agent: Integra as ferramentas, decide qual ferramenta usar e executa a ação adequada.

Etapas da Implementação: Fluxo de Execução

Agora, vamos entender como o agente opera:

Método think: Utiliza o modelo para determinar qual ferramenta deve ser usada e quais entradas são necessárias.
Método work: Executa a ferramenta selecionada com base nas decisões do think.
A saída é formatada como um JSON com tool_choice e tool_input.

Executando o Agente e Considerações Finais

Para finalizar, vejamos como colocar o agente em ação e algumas considerações importantes:

Inicialização do agente: Configura o agente com as ferramentas e o serviço de modelo.
Loop principal: Aceita comandos do usuário até que ‘exit’ seja digitado.
Expansão futura: O agente pode ser melhorado com a adição de mais ferramentas e modelos.

Conclusão

Neste artigo, você aprendeu como construir um agente de IA do zero em Python, integrando modelos de linguagem e ferramentas personalizadas. Este agente é capaz de processar a entrada do usuário, escolher as ferramentas apropriadas e executar tarefas específicas eficientemente.

A construção do agente demonstra a interação entre diferentes componentes, como o modelo de linguagem, as ferramentas e a lógica do agente, orquestrando todo o processo de maneira coesa. Este projeto serve como base para a criação de agentes mais complexos e sofisticados, com capacidades de aprendizado e adaptação ampliadas.

Não pare por aqui! Continue explorando e expandindo as funcionalidades do seu agente de IA. A tecnologia está em constante evolução, e seu potencial é ilimitado.

Está pronto para dar o próximo passo? Inscreva-se em nosso curso avançado de IA e descubra como levar seus projetos ao próximo nível.

Fonte: Singh, Vipra. “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.

Autor: Qwen-Plus

# Construa um Agente de IA do Zero em Python: Passo a Passo

Você já imaginou criar um assistente inteligente que entenda suas necessidades e execute tarefas específicas? Neste artigo, vamos explorar como construir um agente de IA funcional usando Python. Vamos percorrer cada etapa, desde o básico até a execução final. Prepare-se para aprender técnicas poderosas que podem impulsionar seus projetos!

## O que é um Agente de IA?

Um agente de IA é uma entidade autônoma capaz de perceber seu ambiente, tomar decisões e executar ações para alcançar objetivos específicos. Esses agentes variam em complexidade, desde os reativos, que respondem diretamente às mudanças ambientais, até os inteligentes, que aprendem e se adaptam ao longo do tempo.

- **Agentes reativos**: Respondem imediatamente às mudanças sem memória interna.
- **Agentes baseados em modelos**: Utilizam representações internas do mundo para tomar decisões.
- A complexidade aumenta à medida que incorporamos aprendizado e adaptação.

Esses agentes são amplamente utilizados em chatbots, sistemas de recomendação e veículos autônomos, entre outros.

## Pré-requisitos para a Implementação

Antes de começarmos, é essencial configurar o ambiente Python corretamente. Aqui estão os passos básicos:

1. **Instalar Python**: Certifique-se de ter o Python 3.8+ instalado. Verifique com:
   ```bash
   python --version
   ```

2. **Criar um ambiente virtual**: Isso mantém suas dependências organizadas.
   ```bash
   python -m venv ai_agents_env
   source ai_agents_env/bin/activate  # No Windows: ai_agents_env\Scripts\activate
   ```

3. **Instalar as dependências**: Use o arquivo `requirements.txt` fornecido no repositório.
   ```bash
   pip install -r requirements.txt
   ```

4. **Configurar o Ollama localmente**: O Ollama gerencia modelos de linguagem localmente. Siga as instruções no site oficial para instalação.

Com isso pronto, estamos prontos para começar!

## Etapas da Implementação: Definindo Classes e Funções

Agora chegamos ao coração do projeto. Vamos criar as classes e funções necessárias para o funcionamento do agente.

### Classe OllamaModel

Essa classe gerencia a comunicação com o modelo de linguagem via API local do Ollama. Ela recebe uma solicitação do usuário e retorna uma resposta processada.

### Ferramentas Básicas

As ferramentas executam tarefas específicas. Por exemplo:

- **basic_calculator**: Realiza operações matemáticas simples.
- **reverse_string**: Inverte strings conforme solicitado.

### Classe Agent

A classe principal (`Agent`) integra todas as peças. Ela decide qual ferramenta usar e executa a ação correspondente.

## Etapas da Implementação: Fluxo de Execução

O fluxo do agente segue estes passos principais:

1. **think**: Usa o modelo para determinar qual ferramenta e entrada devem ser usados.
2. **work**: Executa a ferramenta escolhida e retorna o resultado formatado.

Exemplo de saída JSON:
```json
{
    "tool_choice": "basic_calculator",
    "tool_input": {
        "num1": 15,
        "num2": 7,
        "operation": "add"
    }
}
</code></pre>

Isso garante que o agente tome decisões informadas com base na entrada do usuário.

<h2>Executando o Agente e Considerações Finais</h2>

Finalmente, inicializamos o agente com as ferramentas e o serviço de modelo configurados. O loop principal aceita comandos do usuário até que a palavra "exit" seja digitada.

<h3>Pontos Importantes:</h3>

<ul>
<li>O agente pode ser expandido para incluir mais ferramentas e modelos.</li>
<li>A interação fluida entre o modelo de linguagem, ferramentas e lógica do agente demonstra sua versatilidade.</li>
</ul>

<h2>Conclusão</h2>

Este tutorial forneceu um guia detalhado para construir um agente de IA em Python, integrando modelos de linguagem e ferramentas personalizadas. Demonstramos como processar entradas do usuário, selecionar ferramentas adequadas e executar tarefas específicas.

A construção do agente destaca a interação entre diferentes componentes: o modelo de linguagem (que processa entradas), as ferramentas (que realizam tarefas) e a lógica do agente (que orquestra todo o processo).

<h3>Próximos Passos</h3>

Este projeto serve como base para agentes mais avançados, com maior capacidade de aprendizado e adaptação. Experimente adicionar mais ferramentas ou integrar diferentes modelos de linguagem para expandir suas funcionalidades.

<em>Fonte: Adaptado de "AI Agents: Build an Agent from Scratch (Part-2)" por Vipra Singh. Disponível em: <a href="https://medium.com/@vipra_singh">Medium</a>.</em>

<pre><code>***
<h1>Autor: DeepSeek R1 </h1>
```markdown
# Construindo um Agente de IA do Zero em Python: Um Guia Passo a Passo

Você já imaginou como seria criar um agente de IA que pode tomar decisões, escolher ferramentas adequadas e executar tarefas com base em comandos simples? Se você é um entusiasta de Python e está curioso para explorar o mundo dos agentes de IA, este guia é para você. Vamos construir um agente de IA do zero, integrando modelos de linguagem e ferramentas personalizadas. Prepare-se para mergulhar em um projeto prático e envolvente!

---

## O que é um Agente de IA?

Um agente de IA é uma entidade autônoma que percebe seu ambiente, toma decisões e executa ações para atingir objetivos específicos. Esses agentes podem variar em complexidade, desde sistemas reativos simples até agentes inteligentes que aprendem e se adaptam ao longo do tempo.

### Tipos de Agentes de IA

1. **Agentes Reativos**: Respondem diretamente a mudanças no ambiente sem memória interna.
2. **Agentes Baseados em Modelos**: Utilizam modelos internos do mundo para tomar decisões.
3. **Agentes Baseados em Objetivos**: Planejam ações para atingir metas específicas.
4. **Agentes Baseados em Utilidade**: Avaliam ações com base em uma função de utilidade para maximizar resultados.

Exemplos de aplicações incluem chatbots, sistemas de recomendação e veículos autônomos. Nosso foco será construir um agente que integra modelos de linguagem e ferramentas customizadas.

---

## Pré-requisitos para a Implementação

Antes de começar, é essencial configurar o ambiente de desenvolvimento. Aqui estão os passos necessários:

### 1. Configuração do Ambiente Python

- **Instale o Python**: Baixe e instale o Python (versão 3.8 ou superior) em [python.org](https://www.python.org/downloads/).
- **Verifique a instalação**:
  ```bash
  python --version
  ```
- **Crie um ambiente virtual**:
  ```bash
  python -m venv ai_agents_env
  source ai_agents_env/bin/activate  # No Windows: ai_agents_env\Scripts\activate
  ```
- **Instale as dependências**:
  ```bash
  pip install requests termcolor python-dotenv
  ```

### 2. Configuração do Ollama

Ollama é uma ferramenta para gerenciar modelos de linguagem localmente. Siga os passos abaixo:

- **Baixe e instale o Ollama** em [ollama.com](https://ollama.com/).
- **Verifique a instalação**:
  ```bash
  ollama --version
  ```
- **Puxe um modelo** (opcional):
  ```bash
  ollama pull mistral
  ```

---

## Etapas da Implementação

### 1. Definindo a Classe do Modelo

A classe `OllamaModel` será responsável por interagir com a API local do Ollama para gerar respostas. Aqui está um exemplo básico:

```python
class OllamaModel:
    def __init__(self, model, system_prompt, temperature=0, stop=None):
        self.model_endpoint = "http://localhost:11434/api/generate"
        self.model = model
        self.system_prompt = system_prompt
        self.headers = {"Content-Type": "application/json"}
        self.temperature = temperature
        self.stop = stop

    def generate_text(self, prompt):
        payload = {
            "model": self.model,
            "prompt": prompt,
            "system": self.system_prompt,
            "temperature": self.temperature,
            "stop": self.stop
        }
        response = requests.post(self.model_endpoint, headers=self.headers, data=json.dumps(payload))
        return response.json()
</code></pre>

<h3>2. Criando Ferramentas para o Agente</h3>

Vamos criar duas ferramentas simples: uma calculadora básica e uma função para inverter strings.

<pre><code class="language-python">def basic_calculator(input_str):
    # Implementação da calculadora
    pass

def reverse_string(input_string):
    # Implementação da inversão de strings
    pass
</code></pre>

<h3>3. Construindo a Caixa de Ferramentas</h3>

A classe <code>ToolBox</code> armazena as ferramentas disponíveis e suas descrições:

<pre><code class="language-python">class ToolBox:
    def __init__(self):
        self.tools_dict = {}

    def store(self, functions_list):
        for func in functions_list:
            self.tools_dict[func.__name__] = func.__doc__
        return self.tools_dict

    def tools(self):
        return "\n".join([f"{name}: {doc}" for name, doc in self.tools_dict.items()])
</code></pre>

<h3>4. Criando a Classe do Agente</h3>

A classe <code>Agent</code> integra tudo: ela decide qual ferramenta usar e executa a ação.

<pre><code class="language-python">class Agent:
    def __init__(self, tools, model_service, model_name, stop=None):
        self.tools = tools
        self.model_service = model_service
        self.model_name = model_name
        self.stop = stop

    def think(self, prompt):
        tool_descriptions = self.prepare_tools()
        agent_system_prompt = agent_system_prompt_template.format(tool_descriptions=tool_descriptions)
        model_instance = self.model_service(model=self.model_name, system_prompt=agent_system_prompt)
        return model_instance.generate_text(prompt)

    def work(self, prompt):
        agent_response_dict = self.think(prompt)
        tool_choice = agent_response_dict.get("tool_choice")
        tool_input = agent_response_dict.get("tool_input")
        for tool in self.tools:
            if tool.__name__ == tool_choice:
                return tool(tool_input)
        return tool_input
</code></pre>

<h3>5. Executando o Agente</h3>

Finalmente, vamos inicializar o agente e começar a interagir com ele:

<pre><code class="language-python">if __name__ == "__main__":
    tools = [basic_calculator, reverse_string]
    model_service = OllamaModel
    model_name = "llama2"
    agent = Agent(tools=tools, model_service=model_service, model_name=model_name)

    while True:
        prompt = input("Ask me anything: ")
        if prompt.lower() == "exit":
            break
        print(agent.work(prompt))
</code></pre>

<hr />

<h2>Conclusão</h2>

Neste tutorial, exploramos como construir um agente de IA do zero em Python. Desde a configuração do ambiente até a criação de ferramentas e a integração com modelos de linguagem, você agora tem uma base sólida para desenvolver agentes mais complexos e adaptáveis.

<h3>Próximos Passos</h3>

<ul>
<li><strong>Expanda as ferramentas</strong>: Adicione mais funcionalidades ao agente.</li>
<li><strong>Integre outros modelos</strong>: Experimente diferentes modelos de linguagem.</li>
<li><strong>Explore aplicações reais</strong>: Use o agente em projetos como chatbots ou automação de tarefas.</li>
</ul>

O mundo dos agentes de IA é vasto e cheio de possibilidades. O que você vai construir a seguir?

<hr />

<strong>Referência Bibliográfica</strong>:<br />
<em>Fonte: Vipra Singh. "AI Agents: Build an Agent from Scratch (Part-2)". Disponível em: <a href="https://medium.com/@vipra_singh/ai-agents-build-an-agent-from-scratch-part-2-7ae11840c93a">https://medium.com/@vipra_singh/ai-agents-build-an-agent-from-scratch-part-2-7ae11840c93a</a>.</em>
```

Autor: GPT4o

Construindo um Agente de IA do Zero em Python

O que é um Agente de IA?

Principais Itens:

Pré-requisitos para a Implementação

Configuração do Ambiente Python

Configurar o Ollama Localmente

Etapas da Implementação: Definindo Classes e Funções

Definindo a Classe do Modelo

Criando Ferramentas para o Agente

Construindo a Caixa de Ferramentas

Criando a Classe do Agente

Etapas da Implementação: Fluxo de Execução

Principais Itens:

Executando o Agente e Considerações Finais

Conclusão

Autor: Claude Sonnet

Construindo um Agente de IA do Zero em Python

O que é um Agente de IA?

Pré-requisitos para Implementação

1. Configurar o Ambiente Python

2. Configurar o Ollama Localmente

Etapas da Implementação

Definindo Classes e Funções

1. Classe do Modelo (OllamaModel)

2. Ferramentas Básicas

Fluxo de Execução

Executando o Agente

Conclusão

Autor: Gemini 2.0 Flash

Construindo um Agente de IA do Zero em Python: Um Guia Passo a Passo

O que é um Agente de IA?

Pré-requisitos para a Implementação

Etapas da Implementação: Definindo Classes e Funções

Executando o Agente e Considerações Finais

Conclusão

Autor: Grok 2

Construindo um Agente de IA do Zero em Python: Um Guia Completo

O que é um Agente de IA?

Pré-requisitos para a Implementação

Etapas da Implementação: Definindo Classes e Funções

Etapas da Implementação: Fluxo de Execução

Executando o Agente e Considerações Finais

Conclusão

Autor: Qwen-Plus

Gostou? Compartilhe!

Curtir isso:

Relacionado