A inteligência artificial tem evoluído rapidamente, e um dos conceitos mais promissores dessa revolução é o Agent AI. Esses agentes inteligentes não apenas processam informações, mas também tomam decisões autônomas e interagem com sistemas e usuários de forma proativa. Vamos explorar o que são Agent AIs, como funcionam e como podem ser aplicados para transformar a automação inteligente e também aplicar usando CrewAI.
O que é um Agent AI?
Um Agent AI (Agente de Inteligência Artificial) é um sistema baseado em IA capaz de operar de forma autônoma para atingir objetivos específicos. Diferente de um chatbot tradicional, que apenas responde a comandos, um Agent AI pode raciocinar, planejar ações e executar tarefas sem intervenção humana constante.
Esses agentes podem ser usados para uma variedade de finalidades, como:
- Automação de processos complexos: Monitoramento de sistemas, tomada de decisões em tempo real e otimização de fluxos de trabalho.
- Atendimento ao cliente avançado: Resolução de problemas, recomendações personalizadas e suporte técnico automatizado.
- Análise de dados inteligente: Coleta, filtragem e interpretação de grandes volumes de dados para tomada de decisões estratégicas.
Como funciona um Agent AI?
Os Agent AIs utilizam diversas tecnologias e abordagens para alcançar um comportamento autônomo e inteligente. Alguns dos principais componentes incluem:
a. Modelos de Machine Learning e LLMs (Large Language Models): Utilizam aprendizado de máquina para processar linguagem natural, reconhecer padrões e tomar decisões baseadas em dados.
b. Raciocínio e Planejamento: Incorporam técnicas como Planejamento Automático e Aprendizado por Reforço para definir estratégias e agir de forma autônoma.
c. Interação com APIs e sistemas externos: Conectam-se a bancos de dados, CRMs, ERPs e outras ferramentas para buscar e processar informações.
d. Memória e Contexto: Diferente de assistentes básicos, os agentes podem manter um histórico de interações e aprender com cada experiência, tornando-se mais eficientes com o tempo.
Aplicações dos Agent AIs
Os Agent AIs estão sendo adotados em diversas indústrias e setores para resolver problemas de maneira inovadora:
a. Empresas e Automação Corporativa
Empresas estão utilizando agentes inteligentes para automatizar tarefas repetitivas, gerenciar fluxos de trabalho e melhorar a eficiência operacional.
b. Assistentes Pessoais e Atendimento ao Cliente
Chatbots tradicionais estão evoluindo para agentes mais inteligentes que conseguem manter contexto, antecipar necessidades do usuário e oferecer recomendações mais precisas.
c. Cibersegurança e Detecção de Ameaças
Com o uso de IA, agentes podem monitorar redes em tempo real, identificar padrões suspeitos e responder automaticamente a possíveis ataques cibernéticos.
d. Pesquisa e Desenvolvimento
Empresas de tecnologia e inovação utilizam Agent AIs para buscar informações, sintetizar relatórios e acelerar o desenvolvimento de novos produtos e soluções.
Desafios na Implementação de Agent AIs
Como nem tudo são flores, apesar dos benefícios, há desafios a serem superados na adoção de agentes de IA:
- Privacidade e Segurança de Dados: Como esses agentes lidam com grandes volumes de informações, é essencial implementar medidas rigorosas de proteção de dados.
- Ética e Transparência: Evitar viés algorítmico e garantir que os agentes tomem decisões justas e imparciais.
- Complexidade Técnica: Desenvolver e treinar agentes de IA requer expertise em machine learning e integração com sistemas empresariais.
- Recursos Computacionais: O processamento de modelos avançados demanda infraestrutura robusta, impactando custos e escalabilidade.
- Alucinação: Como os modelos de IA podem gerar respostas imprecisas ou fictícias, há o risco de fornecer informações erradas, o que pode impactar a confiabilidade dos agentes em aplicações críticas.
- Não-determinismo: Como a IA pode gerar respostas diferentes para a mesma entrada, isso dificulta a previsibilidade e a consistência dos resultados, sendo um desafio para aplicações que exigem decisões padronizadas.
Tipos de Agent AIs
As organizações utilizam diferentes tipos de agentes inteligentes para atender a necessidades específicas:
a. Agentes Reflexos Simples
Operam com base em regras predefinidas e dados imediatos, sendo ideais para tarefas simples.Tomam decisões baseadas apenas na percepção atual, respondendo a sinais ambientais imediatos sem qualquer memória interna de acontecimentos passados.
Exemplos:
- um sistema de resposta automática que redefine senhas ao detectar palavras-chave em solicitações de suporte.
- um termóstato que liga o ar condicionado quando a temperatura atual ultrapassa um determinado limite é um agente reflexo simples.
b. Agentes Reflexos Baseados em Modelos
Possuem mecanismos de decisão mais avançados, avaliando consequências antes de agir, criando um modelo interno do ambiente percebido.
Exemplo:
- um sistema de controle de tráfego que ajusta sinais de trânsito com base no fluxo de veículos detectado.
c. Agentes Baseados em Metas
Comparam diferentes abordagens para alcançar objetivos de maneira eficiente, sendo aplicados em processamento de linguagem natural e robótica.Utilizam sensores para recolher informações e consideram o historial de percepções, permitindo uma tomada de decisões mais sofisticada.
Exemplos:
- um robô autônomo que navega por um armazém para coletar e organizar pacotes com base em metas de entrega.
- uma IA que joga xadrez e que considera o histórico de jogadas e o estado atual do tabuleiro para decidir a próxima jogada é um agente baseado em modelos.
d. Agentes Baseados em Serviços Utilitários
Usam algoritmos para maximizar benefícios aos usuários, analisando cenários para tomar decisões otimizadas.
Exemplo:
- um agente que monitora preços de passagens aéreas e recomenda a melhor compra com base na relação custo-benefício.
- uma IA de consultor de investimentos que avalia várias opções de investimento com base em potenciais retornos e riscos é um agente baseado em objetivos.
e. Agentes de Aprendizagem
Melhoram continuamente com base em experiências passadas, utilizando feedback para aprimorar decisões ao longo do tempo.Um elemento de aprendizagem permite-lhes adquirir novos conhecimentos e ajustar o seu comportamento com base na experiência.
Exemplos:
- um assistente virtual que aprende preferências do usuário para sugerir conteúdos ou ajustar configurações automaticamente.
- um filtro de spam que aprende a identificar novos tipos de e-mails de spam com base no feedback do utilizador é um agente de aprendizagem.
f. Agentes Hierárquicos
Compostos por múltiplos agentes organizados em camadas, onde agentes superiores delegam tarefas a subordinados para otimizar execuções complexas.Esta organização permite o tratamento eficiente de tarefas complexas através da divisão de responsabilidades entre diferentes níveis.
Exemplos:
- um sistema de gerenciamento logístico onde agentes individuais coordenam transporte, estoque e distribuição de mercadorias.
- num processo de fabrico, um sistema de agentes hierárquicos pode ter um agente de alto nível que gere os objetivos globais de produção e agentes de nível inferior que controlam máquinas individuais.
O que é CrewAI?
CrewAI é um conceito que envolve a criação de times de agentes de IA com habilidades complementares, que trabalham juntos para alcançar objetivos específicos. Diferente de um único modelo de IA que tenta resolver tudo sozinho, o CrewAI distribui responsabilidades entre agentes especializados, melhorando a precisão, a eficiência e a escalabilidade das soluções.
Como funciona?
O CrewAI opera baseado na colaboração entre agentes, onde cada um desempenha um papel específico. A estrutura geral inclui:
- Papel dos Agentes – Cada agente possui uma especialização, como processamento de dados, análise de contexto, geração de texto, ou tomada de decisão.
- Coordenação – Um sistema central ou um agente líder distribui tarefas e gerencia a comunicação entre os agentes.
- Execução e Feedback – Os agentes executam suas partes da tarefa e compartilham resultados entre si para refinar a solução final.
Benefícios do CrewAI
✅ Maior Eficiência – Distribuir tarefas entre agentes especializados melhora a performance.
✅ Redução de Erros – O trabalho colaborativo permite verificações cruzadas entre agentes.
✅ Escalabilidade – Equipes de agentes podem crescer ou se adaptar às necessidades do sistema.
✅ Tomada de Decisão Melhorada – A especialização dos agentes leva a análises mais detalhadas.
Desafios do CrewAI
🚧 Coordenação Complexa – Garantir que os agentes colaborem de forma eficaz pode exigir sistemas sofisticados de comunicação.
🚧 Uso de Recursos – Dependendo da complexidade, a execução pode demandar alto poder computacional.
🚧 Interpretação e Consistência – Integrar diferentes respostas pode gerar variações inesperadas nos resultados.
Mão na Massa
Para os exemplos, vamos criar os seguintes agentes usando o CrewAI:
- Um agente para redigir blogs;
- Um agente que utiliza linguagem natural para realizar consultas em uma base de dados;
- Um agente interpretador de código, que recebe comandos em linguagem natural e os executa no sistema operacional.
Requisitos:
- Python >= 3.12;
- Gerenciador de pacotes uv;
- Docker
O Agente no CrewAI e composto por:
- role: É fundamental porque ele dá identidade ao agente. É o role que orienta o agente sobre suas responsabilidades e o que se espera dele. Por exemplo, se o agente tem o papel de 'Pesquisador', ele sabe que deve focar em coletar informações e analisar dados.
- goal: É como o norte de uma bússola para o agente.Ele orienta todas as ações e decisões do agente, garantindo que ele esteja sempre trabalhando em direção ao objetivo desejado. Por exemplo, um agente com o goal de 'coletar dados de mercado' vai focar todas as suas atividades em encontrar, analisar e compilar informações relevantes sobre o mercado.
- backstory: Este atributo é como o histórico de um personagem em um filme ou livro. Ele fornece contexto e profundidade ao agente, moldando suas ações e decisões de maneira que façam sentido dentro do seu "universo". No CrewAI, o backstory de um agente é fundamental para criar agentes que não apenas realizam tarefas, mas que também possuem uma lógica interna consistente para suas ações. O backstory é crucial porque ele influencia diretamente como o agente se comporta e responde a diferentes situações. Por exemplo, um agente com um histórico de 'Pesquisador Acadêmico' abordará um problema de maneira muito diferente de um agente com um histórico de 'Empreendedor'. O primeiro pode ser mais meticuloso e detalhista, enquanto o segundo pode ser mais inovador e orientado a riscos. Esse contexto adicional ajuda a definir as expectativas e a prever o comportamento do agente, tornando suas ações mais coerentes e previsíveis.
O Tarefa no CrewAI e composto por:
agent: No CrewAI, todo agente é designado para uma task. Isso significa que, antes de criar uma tarefa no CrewAI, você deve criar o agente. Isso ocorre porque, na declaração da task, espera-se a especificação de um agente.
description: No CrewAI, a 'description' é o coração de uma task. Ela diz exatamente o que precisa ser feito, como e por quê. Pensar em uma 'description' é como escrever o roteiro de um filme, você precisa ser claro, conciso e detalhado o suficiente para que ninguém se perca no meio do caminho.
expected_output: O expected_output funciona como um acordo entre você e o agente. Ele especifica exatamente o que deve ser entregue ao final da execução da tarefa. Isso é crucial para garantir que os agentes estejam alinhados com os objetivos do projeto e que o resultado final esteja de acordo com o que foi solicitado.
Tanto Agente quanto Tarefa podemos usar a "mente pensante" que são os LLM ou SLM, podemos adicionar através da propriedade llm.
Existem outros atributos, para mais detalhes acesse a documentação CrewAI Docs.
Os exemplos que vou disponibilizar usaram:
- openai/gpt-4o-mini
- deepseek/deepseek-chat
- ollama/deepseek-r1:8b
Além de usar as plataformas online da openai e deepseek foi usado local na minha maquina com Ollama.
Requisitos da minha máquina:
- OS: Linux Mint 21.1 x86_64
- NVIDIA GeForce GTX 1660 Ti 6GB GDDR6
- 32GB de RAM
- CPU: Intel i7-9750H (12) @ 4.500GHz
Para rodar os exemplo na raiz do projeto:
- Para rodar o Redigir Blog:
uv run python ./blogs/main.py
- Para rodar o SQL Query AI:
uv run python ./query/main.py
- Para rodar Interpretador:
uv run python ./interpretador/main.py
1. Agentes para redigir blogs;
A criação da equipe de agentes é clara, simples e intuitiva. Cada agente possui um papel específico, metas individuais e tarefas a serem executadas, todas alinhadas para alcançar o objetivo final de maneira colaborativa e eficaz.
import os
from dotenv import load_dotenv
from crewai import Agent, Task, Crew, Process, LLM
from llm_model import LLMModel
from llm_type import LLMType
class CreateBlogWriter:
def __init__(self, type):
load_dotenv ()
llm_model = LLMModel()
self.llm = (
llm_model.open_ai_gpt_4o_mini() if LLMType(type) == LLMType.OPEN_AI_GPT_4O_MINI
else llm_model.deepseek(os.getenv("DEEPSEEK_API_KEY")) if LLMType(type) == LLMType.DEEPSEEK
else llm_model.ollama_deepseek()
)
self.create_crew()
def create_crew(self):
"""
Agentes
"""
self.planner = Agent(
role = "Planejador de Conteúdo",
goal = "Planejar conteúdo envolvente e factualmente preciso sobre {topic}",
backstory = "Você está trabalhando no planejamento de um artigo de blog "
"sobre o tema: {topic} no 'https://medium.com/'."
"Você coleta informações que ajudam o "
"público a aprender algo e tomar decisões informadas. "
"Você precisa preparar um esboço detalhado "
"com os tópicos e subtópicos relevantes que devem fazer parte do artigo de blog."
"Seu trabalho é a base para o Redator de Conteúdo escrever um artigo sobre este tema.",
llm = self.llm,
allow_delegation = False,
verbose = True
)
self.writer = Agent(
role = "Redator de Conteúdo",
goal = "Escrever um artigo de opinião perspicaz e factualmente preciso "
"sobre o tema: {topic}",
backstory = "Você está trabalhando na escrita de um "
"novo artigo de opinião sobre o tema: {topic} no 'https://medium.com/'. "
"Você baseia sua escrita no trabalho do Planejador de Conteúdo, que fornece um esboço e contexto relevante sobre o tema. "
"Você segue os principais objetivos e direção do esboço, conforme fornecido pelo Planejador de Conteúdo. "
"Você também fornece insights objetivos e imparciais e os embasa com informações fornecidas pelo Planejador de Conteúdo. "
"Você reconhece em seu artigo de opinião quando suas afirmações são opiniões e não declarações objetivas.",
allow_delegation = False,
llm = self.llm,
verbose = True
)
self.editor = Agent(
role = "Editor",
goal = "Editar um post de blog dado para alinhar com "
"o estilo de escrita da organização 'https://medium.com/'. ",
backstory = "Você é um editor que recebe um post de blog do Redator de Conteúdo. "
"Seu objetivo é revisar o post de blog para garantir que ele siga as melhores práticas jornalísticas,"
"forneça pontos de vista equilibrados ao apresentar opiniões ou afirmações, "
"e também evite tópicos controversos ou opiniões, sempre que possível.",
llm = self.llm,
allow_delegation = False,
verbose = True
)
"""
Tarefas
"""
self.plan = Task(
description = (
"1. Priorize as últimas tendências, principais players, "
"e notícias relevantes sobre {topic}.\n"
"2. Identifique o público-alvo, considerando "
"seus interesses e pontos de dor.\n"
"3. Desenvolva um esboço detalhado do conteúdo, incluindo "
"uma introdução, pontos principais e uma chamada para ação.\n"
"4. Inclua palavras-chave de SEO e dados ou fontes relevantes."
),
expected_output = "Um documento de plano de conteúdo abrangente "
"com um esboço, análise do público, palavras-chave de SEO e recursos.",
agent = self.planner,
)
self.write = Task(
description = (
"1. Use o plano de conteúdo para criar um post de blog envolvente "
"sobre {topic}.\n"
"2. Incorpore palavras-chave de SEO de forma natural.\n"
"3. As seções/Subtítulos são nomeadas de forma apropriada "
"e envolvente.\n"
"4. Certifique-se de que o post esteja estruturado com uma "
"introdução envolvente, corpo perspicaz, "
"e uma conclusão resumida.\n"
"5. Revise erros gramaticais e "
"alinhamento com a voz da marca.\n"
),
expected_output = "Um post de blog bem escrito "
"em formato markdown, pronto para publicação, cada seção deve ter 2 ou 3 parágrafos.",
agent = self.writer,
)
self.edit = Task(
description = ( "Revise o post de blog dado para verificar "
"erros gramaticais e alinhamento com a voz da marca."),
expected_output = "Um post de blog bem escrito em formato markdown, "
"pronto para publicação, cada seção deve ter 2 ou 3 parágrafos.",
agent = self.editor
)
"""
Crew
"""
self.crew = Crew(
agents = [self.planner, self.writer, self.editor],
tasks = [self.plan, self.write, self.edit],
process = Process.sequential,
verbose = True
)
def kickoff(self, topic):
result = self.crew.kickoff(inputs={"topic":topic})
return result
Fluxo
O fluxo representa um sistema de geração de conteúdo estruturado usando agentes de IA para automatizar o processo de criação de um artigo de blog. Ele é baseado em um pipeline onde diferentes agentes desempenham papéis específicos no planejamento, redação e edição do conteúdo antes da publicação.
Componentes Principais
a. Agentes (Agents)
Planejador de Conteúdo (self.planner): Responsável por estruturar um esboço detalhado do artigo, identificando tópicos relevantes, tendências, público-alvo e palavras-chave de SEO.
Redator de Conteúdo (self.writer): Baseando-se no plano do Planejador, escreve um artigo bem estruturado, utilizando palavras-chave e seguindo um estilo envolvente e informativo.
Editor (self.editor): Faz a revisão do artigo para garantir que esteja alinhado com o estilo da plataforma, corrigindo erros e ajustando a estrutura para melhor legibilidade.
b. Tarefas (Tasks)
Planejamento (self.plan): Criação do esboço do artigo, definição do público-alvo e levantamento de informações relevantes.
Escrita (self.write): Redação do artigo com base no plano, garantindo estrutura coerente e aplicação de SEO.
Edição (self.edit): Revisão do artigo para garantir qualidade, coerência e alinhamento com a voz da marca.
c. Execução (Crew)
O sistema orquestra os agentes e tarefas de forma sequencial, garantindo que cada etapa seja concluída antes da próxima.
Cada agente recebe suas respectivas tarefas e executa suas funções até o artigo estar pronto para publicação.
d. Fluxo de Trabalho
O Planejador de Conteúdo analisa o tópico e cria um esboço estruturado com palavras-chave, público-alvo e seções importantes.
O Redator de Conteúdo usa esse esboço para escrever o artigo, organizando bem a informação e garantindo uma leitura fluida.
O **Editor revisa **o texto para corrigir erros, melhorar o estilo e garantir que o artigo siga o padrão esperado.
O artigo final passa pelo processo completo e fica pronto para publicação.
2. Agente que utiliza linguagem natural para realizar consultas em uma base de dados
Usa inteligência artificial para gerar consultas SQL otimizadas a partir de descrições textuais do usuário. Ele combina agentes inteligentes da CrewAI e modelos de linguagem grandes (LLMs) para interpretar a estrutura do banco e construir queries eficientes.
Saída:
🔍 Consulta SQL Gerada:
SELECT nome, preco
FROM produtos
WHERE preco > 100
ORDER BY preco
LIMIT 5;
nome preco
0 Bola de Futebol Pro 129.90
1 Controle Sem Fio Elite 249.90
2 Tênis Esportivo Ultra 259.90
3 Fone Bluetooth SoundX 299.90
4 Conjunto de Panelas 299.90
import os
from dotenv import load_dotenv
from crewai import Agent, Task, Crew, Process
from crewai_tools import FileReadTool
from llm_model import LLMModel
from llm_type import LLMType
class SQLQueryAI:
def __init__(self, type):
load_dotenv()
llm_model = LLMModel()
self.llm = (
llm_model.open_ai_gpt_4o_mini() if LLMType(type) == LLMType.OPEN_AI_GPT_4O_MINI
else llm_model.deepseek(os.getenv("DEEPSEEK_API_KEY")) if LLMType(type) == LLMType.DEEPSEEK
else llm_model.ollama_deepseek()
)
self.schema_tool = FileReadTool()
self.crew = None
self.create_crew()
def create_crew(self):
"""Agente especialista em SQL"""
self.sql_agent = Agent(
role="Especialista em SQL",
goal="Gerar consultas SQL precisas e otimizadas para diferentes bancos de dados.",
backstory=(
"Você é um renomado especialista em SQL, com conhecimento avançado em diversas bases de dados, incluindo Postgres, MySQL e SQL Server. "
"Sua missão é interpretar descrições textuais e transformá-las em consultas SQL eficientes, sempre considerando a estrutura do banco de dados."
),
tools=[self.schema_tool],
verbose=True,
memory=True,
llm=self.llm
)
"""Tarefa que o agente executará"""
self.task = Task(
description=(
r"""A partir do meu gerenciador {database_type},
no banco de dados '{database_name}',
e do esquema fornecido no arquivo
YAML localizado em {yaml_path},
gere uma consulta SQL otimizada para
atender ao seguinte pedido:
{user_request}.
Certifique-se de usar as tabelas e colunas
corretas conforme a estrutura do YAML.
O valor inserido em 'json_output' é {json_output}.
IMPORTANTE:
- **Formato de Retorno:**
Se 'json_output' for **True**, a consulta deve retornar os dados em formato JSON,
usando as funções apropriadas para cada banco de dados:
- **Postgres:** 'row_to_json()' ou 'json_agg()'
- **MySQL:** 'JSON_OBJECT()' ou 'JSON_ARRAYAGG()'
- **SQL Server:** 'FOR JSON AUTO'
- **Oracle:** 'JSON_OBJECT()'
Caso contrário, a consulta deve ser otimizada para um **retorno tabular tradicional**.
- **Otimização:**
- Sempre utilize **índices disponíveis** para melhorar a performance.
- Se houver junções ('JOINs'), prefira **chaves indexadas** para evitar scans desnecessários.
- Ordene os resultados de maneira lógica se necessário ('ORDER BY').
- **Considerações Específicas:**
- Evite selecionar colunas desnecessárias (`SELECT *` não é recomendado).
- Se a consulta precisar de filtros ('WHERE'), utilize os campos de indexação do banco de dados para maior eficiência.
- Para valores nulos, utilize funções adequadas como `COALESCE()` para garantir legibilidade no resultado.
"""
),
expected_output="Uma consulta SQL válida e otimizada para o banco de dados especificado.",
agent=self.sql_agent
)
self.crew = Crew(
agents=[self.sql_agent],
tasks=[self.task],
process=Process.sequential
)
def kickoff(self, inputs):
"""
Executa o processo de geração de consultas SQL.
Args:
inputs (dict): Dicionário contendo os parâmetros de entrada:
- database_type (str): Tipo do banco de dados (Postgres, MySQL, etc.).
- database_name (str): Nome do banco de dados.
- yaml_path (str): Caminho do arquivo YAML contendo a estrutura do banco.
- user_request (str): Pedido textual para gerar a consulta SQL.
- json_output (bool): Define se a consulta deve retornar um JSON ou um formato tabular.
Returns:
str: A consulta SQL gerada no formato esperado.
"""
result = self.crew.kickoff(inputs=inputs).raw
result = result.replace("sql","")
result = result.replace("", "")
return result
a. Definição do Agente (sql_agent)
self.sql_agent = Agent(
role="Especialista em SQL",
goal="Gerar consultas SQL precisas e otimizadas para diferentes bancos de dados.",
backstory=(
"Você é um renomado especialista em SQL, com conhecimento avançado em diversas bases de dados, incluindo Postgres, MySQL e SQL Server. "
"Sua missão é interpretar descrições textuais e transformá-las em consultas SQL eficientes, sempre considerando a estrutura do banco de dados."
),
tools=[self.schema_tool],
verbose=True,
memory=True,
llm=self.llm
)
Cria um agente de IA chamado sql_agent, que tem o papel de especialista em SQL.
O agente possui um objetivo claro: gerar consultas SQL precisas e otimizadas.
Sua história reforça que ele tem conhecimento avançado em SQL e deve transformar descrições textuais em queries eficientes.
O agente pode usar ferramentas (tools), sendo que self.schema_tool é uma ferramenta para ler o esquema do banco de dados (YAML).
O modelo de linguagem (llm) escolhido é passado para que o agente utilize ao gerar as respostas.
As opções:
- verbose=True: Faz com que o agente forneça logs detalhados de suas ações.
- memory=True: Permite que o agente retenha informações entre execuções.
b. Definição da Tarefa (task)
self.task = Task(
description=(
r"""A partir do meu gerenciador {database_type},
no banco de dados '{database_name}',
e do esquema fornecido no arquivo
YAML localizado em {yaml_path},
gere uma consulta SQL otimizada para
atender ao seguinte pedido:
{user_request}.
Certifique-se de usar as tabelas e colunas
corretas conforme a estrutura do YAML.
O valor inserido em `json_output` é {json_output}.
IMPORTANTE:
- **Formato de Retorno:**
Se `json_output` for **True**, a consulta deve retornar os dados em formato JSON,
usando as funções apropriadas para cada banco de dados:
- **Postgres:** `row_to_json()` ou `json_agg()`
- **MySQL:** `JSON_OBJECT()` ou `JSON_ARRAYAGG()`
- **SQL Server:** `FOR JSON AUTO`
- **Oracle:** `JSON_OBJECT()`
Caso contrário, a consulta deve ser otimizada para um **retorno tabular tradicional**.
- **Otimização:**
- Sempre utilize **índices disponíveis** para melhorar a performance.
- Se houver junções (`JOINs`), prefira **chaves indexadas** para evitar scans desnecessários.
- Ordene os resultados de maneira lógica se necessário (`ORDER BY`).
- **Considerações Específicas:**
- Evite selecionar colunas desnecessárias (`SELECT *` não é recomendado).
- Se a consulta precisar de filtros (`WHERE`), utilize os campos de indexação do banco de dados para maior eficiência.
- Para valores nulos, utilize funções adequadas como `COALESCE()` para garantir legibilidade no resultado.
"""
),
expected_output="Uma consulta SQL válida e otimizada para o banco de dados especificado.",
agent=self.sql_agent
)
Define a tarefa do agente (task), que é gerar uma consulta SQL otimizada com base em:
O gerenciador de banco de dados (database_type, como Postgres ou MySQL).
O nome do banco de dados (database_name).
O arquivo YAML contendo o esquema (yaml_path).
A solicitação do usuário (user_request).
O formato de saída esperado (json_output).
Diretrizes importantes:
Se json_output for True, a query deve retornar um JSON, usando a função apropriada para o banco de dados.
Caso contrário, a consulta deve ser otimizada para um formato tabular tradicional.
O agente deve seguir boas práticas de SQL:
Evitar '*SELECT **'.
Usar índices para melhorar a performance.
Escolher chaves indexadas para JOINs.
Aplicar filtros eficientes com WHERE.
Usar COALESCE() para lidar com valores NULL.
Fluxo Geral
O objeto SQLQueryAI é instanciado e um modelo LLM (como GPT-4o, DeepSeek ou Ollama) é escolhido.
O agente sql_agent é criado como um especialista em SQL.
Uma tarefa é definida, instruindo o agente a gerar consultas SQL otimizadas.
A equipe (crew) é formada, incluindo o agente e sua tarefa.
Quando o método kickoff(inputs) for chamado:
O agente recebe os parâmetros (database_type, database_name, yaml_path, user_request, json_output).
Ele lê o esquema do banco no arquivo YAML.
O LLM gera uma consulta SQL otimizada seguindo as regras definidas.
O resultado é formatado e retornado ao usuário.
3. Agente interpretador de código, que recebe comandos em linguagem natural e os executa no sistema operacional
Define um sistema baseado na biblioteca CrewAI, no qual um agente chamado Software Engineer pode executar comandos de linha de comando (CLI) de forma automatizada, utilizando o Open Interpreter para interpretar e executar esses comandos.
from crewai import Agent, Task, Crew, Process, LLM
from cli_tool import CLITool
class Command:
def __init__(self):
self.llm = LLM(model="openai/gpt-4o-mini", )
self.cli = CLITool()
self.create_crew()
def create_crew(self):
"""Agent Software Engineer."""
self.software_engineer = Agent(
role="Software Engineer",
goal="Always use Executor Tool. Ability to perform CLI operations, write programs and execute using Exector Tool",
backstory='Expert in command line operations, creating and executing code.',
tools=[self.cli.execute_cli_command],
llm=self.llm,
verbose=True
)
self.software_engineer_task = Task(
description="Execute the command {command} using the Executor Tool.",
expected_output="The expected output of the executed CLI command.",
agent=self.software_engineer,
tools=[self.cli.execute_cli_command],
verbose=True
)
self.crew = Crew(
agents=[self.software_engineer],
tasks=[ self.software_engineer_task],
process=Process.sequential,
manager_llm=self.llm,
verbose=True
)
def kickoff(self, inputs):
result = self.crew.kickoff(inputs=inputs)
return result
Ferramenta CLI:
from crewai.tools import tool
from interpreter import interpreter
class CLITool:
interpreter.auto_run = True
interpreter.llm.model = "openai/gpt-4o-mini"
@tool("executor")
def execute_cli_command(command:str):
"""Create an Execute code using Open Interpreter."""
result = interpreter.chat(command)
return result
Fluxo:
a. Criação do Agente (software_engineer)
Ele tem o papel de Engenheiro de Software e pode executar comandos CLI.
Usa a ferramenta Executor Tool (self.cli.execute_cli_command).
b. Criação da Tarefa (software_engineer_task)
Instrução clara: "Execute o comando {command} usando Executor Tool".
A saída esperada é o resultado do comando.
c. Criação da Equipe (Crew)
Agrupa o agente e a tarefa.
Garante que os comandos sejam executados um de cada vez (Process.sequential).
Usa GPT-4o-mini para gerenciar a execução.
🛠 Como Esse Código Funciona na Prática?
Exemplo de Execução:
cmd = Command()
result = cmd.kickoff({"command": "ls -l"})
print(result)
O agente recebe o comando "ls -l".
Ele usa a ferramenta Executor Tool para executar o comando.
O resultado da execução (lista de arquivos) é retornado.
O Futuro dos Agent AIs
A tendência é que os Agent AIs se tornem cada vez mais sofisticados, combinando IA generativa, aprendizado por reforço e interações multimodais (texto, voz e imagem). Esses agentes terão um impacto significativo na automação e na experiência do usuário.
Desde o atendimento ao cliente até a gestão empresarial e segurança digital.
O código completo: Agent AI
Referências
ARCHITECTURE FOR ADAPTIVE INTELLIGENT
SYSTEMS
Processamento de Linguagem Natural
Livro Inteligência Artificial - Uma Abordagem de Aprendizado de Máquina
Top comments (1)
Muito bom! O exemplo prático no artigo proporcionou uma compreensão mais clara sobre o funcionamento da delegação de tarefas entre os agentes de IA e os desafios envolvidos.