Seu Agente poderia ser um prompt
Não é pra desanimar
O universo da Inteligência Artificial é fascinante, mas vamos ser sinceros: boa parte do nosso tempo é gasta no famoso processo de tentativa e erro. Se você está estudando IA, já deve ter sentido isso. A gente testa, quebra, aprende e tenta de novo. Longe de mim querer desanimar você. Pelo contrário, quero compartilhar uma jornada prática que mostra exatamente esse ciclo.
Como o tema de agentes de IA está super em alta, decidi mergulhar de cabeça e construir um para realizar análises financeiras. Fui de um simples script em Python para orquestrar um time de agentes especializados e, no final, descobrir que um prompt bem construído poderia ser a ferramenta mais poderosa de todas.
O que é um Agente de IA de Verdade?
Antes de colocar a mão no código, precisamos alinhar as expectativas. Quando falamos de "agente de IA", não estamos falando apenas de um chatbot. Um agente de verdade é a união poderosa entre IA e automação inteligente.
Ele sai da caixinha do chat para se conectar a outros sistemas, entender o que está acontecendo no mundo real e executar tarefas.
O que ele faz?
O que ele (geralmente) NÃO faz?
Com essa definição em mente, meu objetivo era criar um agente que fizesse análises financeiras semanais, avaliando o mercado, identificando tendências e medindo riscos.
Passo 1: O Começo Simples com Python e OpenAI
Todo grande projeto começa com um pequeno passo. O meu foi criar um script para analisar o sentimento de notícias financeiras. A ideia era simples: pegar as manchetes de um portal e usar a API da OpenAI para classificar se o sentimento era positivo, negativo ou neutro.
Primeiro, coletei as notícias usando requests para acessar a página e BeautifulSoup para extrair os títulos e parágrafos.
Analise de sentimento
import requests
import openai
from bs4 import BeautifulSoup
header = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.89 Safari/537.36"
}
openai.api_key = <KEY>
url = 'https://maisretorno.com/portal/noticias/mercado-financeiro'
response = requests.get(url, header)
soup = BeautifulSoup(response.content, 'html.parser')
#find articles
articles = soup.find_all('div', class_='MuiGrid-root MuiGrid-container css-1d3bbye')
#create news
list_news = []
for article in articles:
title = article.find('h3', class_='MuiTypography-root MuiTypography-body1 css-fuk7hj').get_text().strip()
paragraph = article.select_one(':nth-child(3)').get_text().strip()
topc = title + ' ' + paragraph
list_news.append(topc)
print(list_news)
Com a lista de notícias em mãos, fiz um loop para enviar cada uma para a OpenAI e pedir a análise de sentimento.
sentiment_score = []
for news in list_news:
pronpt = 'Please review the article: \n\n '+ news + ' \n\n And check whether they are positive, negative, or neutral.'
response2 = openai.Completion.create(
model="text-davinci-002",
prompt=pronpt,
max_tokens=1024,
n=1,
stop=None,
temperature=0.7,
)
sentiment = response2.choices[0].text.strip()
sentiment_score.append(sentiment)
sentiment_scoreO resultado foi uma lista de classificações, como ['Positive', 'Negative', 'Neutral', ...]. Funcionou! Foi um ótimo começo, mas para uma análise financeira de verdade, eu precisava de muito mais.
Fui aumentando o nivel
Pedi para analizar ações
pronpt = 'Lista das 10 empresas que estão listadas na B3 e nunca tiveram prejuizon onde o P/L estão abaixo de 10 ate 2024'
response2 = openai.Completion.create(
model="text-davinci-002",
prompt=pronpt,
max_tokens=1024,
n=1,
stop=None,
temperature=0.7,
)
sentiment = response2.choices[0].text.strip()
print(sentiment)Passo 2: Montando um "Time" de Agentes na Mão
Usando ferramentas mescladas com prompt. A análise de sentimento era apenas uma peça do quebra-cabeça. Eu precisava de dados financeiros, como preços de ações e indicadores. A solução foi evoluir o script e começar a usar ferramentas como yfinance para buscar dados do Yahoo Finance e googlesearch para encontrar notícias mais específicas.
A ideia era criar um "time" de especialistas, onde cada um tinha uma função:
1. Pesquisador de Notícias: Usava o googlesearch para encontrar artigos sobre um ticker específico (ex: PETR4.SA).
2. Analista de Dados: Usava o yfinance para pegar o histórico de preços e informações da empres.
3. Inteligência Central (IA): Recebia os dados resumidos e gerava uma análise consolidada.
4. Tradutor: Traduzia o resultado final para o português.
Estruturei isso usando classes em Python, onde cada agente tinha sua responsabilidade.
.....
class FinanceAgent(BaseAgent):
def __init__(self):
super().__init__(
name="Finance Agent",
role="Get financial data and interpret trends.",
instructions=[
"Retrieve stock prices, analyst recommendations, and key financial data.",
"Focus on trends and present the data in tables with key insights."
]
)
def get_stock_data(self, symbol: str, start_date: str, end_date: str) -> dict[
str, Union[Union[DataFrame, dict], Any]]:
stock = yf.Ticker(symbol)
hist = stock.history(start=start_date, end=end_date)
recommendations = stock.recommendations
info = stock.info
return {
'history': hist,
'recommendations': recommendations,
'info': info
}
class AnalystAgent(BaseAgent):
def __init__(self):
super().__init__(
name="Analyst Agent",
role="Ensure thoroughness and draw conclusions.",
instructions=[
"Check outputs for accuracy and completeness.",
"Synthesize data to provide a final sentiment score (1-10) with justification."
]
)
class AgentTeam:
def __init__(self):
self.sentiment_agent = SentimentAgent()
self.finance_agent = FinanceAgent()
self.analyst_agent = AnalystAgent()
self.translate_agent = Translate()
self.client = OpenAI()
def analyze_companies(self, companies: List[str], start_date: str, end_date: str) -> str:
results = []
for company in companies:
# Gather news sentiment
news_articles = self.sentiment_agent.search_news(company, start_date, end_date)
news_analysis = self.sentiment_agent.execute(
f"Analyze these articles about {company}: {[article.url for article in news_articles]}"
)
# Gather financial data
financial_data = self.finance_agent.get_stock_data(company, start_date, end_date)
financial_analysis = self.finance_agent.execute(
f"Analyze this financial data for {company}: {financial_data}"
)
# Final analysis
final_analysis = self.analyst_agent.execute(
f"""Synthesize this information for {company}:
News Analysis: {news_analysis}
Financial Analysis: {financial_analysis}"""
)
translate = self.translate_agent.execute(final_analysis)
results.append(final_analysis)
results.append("---------------------------------------")
results.append(translate)
return "\n\n".join(results)
if __name__ == "__main__":
team = AgentTeam()
companiesFind = ['CSMG3.SA']
analysis = team.analyze_companies(
companiesFind,
start_date="2025-01-02",
end_date="2025-01-20"
)Isso já era muito mais poderoso! Mas orquestrar tudo manualmente, controlar o fluxo de dados e garantir que um agente esperasse pelo outro começou a ficar complicado. Foi quando um amigo me deu uma dica de ouro: use um framework!
Passo 3: A Chegada dos Frameworks - Olá, CrewAI!
Frameworks como CrewAI e LangChain foram criados exatamente para resolver esse problema de orquestração. Eles fornecem uma estrutura para definir agentes, suas tarefas e como eles colaboram. Escolhi o CrewAI pela sua simplicidade e conceito intuitivo de "tripulação".
Com o CrewAI, os conceitos ficam mais claros:
Para testar, criei um "coach financeiro" que analisava uma lista de gastos e dava dicas de economia.
Exemplo de código
from crewai import Agent, Task, Crew
from crewai.flow.flow import Flow, listen, start
from dataclasses import dataclass
from dotenv import load_dotenv
import pandas as pd
@dataclass
class DadosFinanceiros:
descricao: str
valor: float
# Função para analisar os dados financeiros do usuário
def analisar_financas(dados):
df = pd.DataFrame(dados)
df['Categoria'] = df['Descricao'].apply(categorizar_gasto)
resumo = df.groupby('Categoria')['Valor'].sum()
return {'gastos': resumo.to_dict()}
# Função para categorizar os gastos
def categorizar_gasto(descricao):
categorias = {
'supermercado': 'Alimentação',
'restaurante': 'Alimentação',
'aluguel': 'Moradia',
'luz': 'Moradia',
'transporte': 'Transporte',
'gasolina': 'Transporte'
}
for chave, categoria in categorias.items():
if chave in descricao.lower():
return categoria
return 'Outros'
# Criando um Agente IA especializado em Finanças
coach_financeiro = Agent(
role='Coach Financeiro Pessoal',
goal='Auxiliar no gerenciamento financeiro e sugerir estratégias para otimização.',
backstory='Especialista em finanças pessoais e planejamento patrimonial.',
verbose=True
)
# Criando uma tarefa para o agente
analise_tarefa = Task(
description='Analisar os padrões de consumo e sugerir ajustes para otimização financeira. dos seguintes gastos {gastos}. Deve se ater aos gastos passados. deve ser considerado uma familha com 3 pessoas',
agent=coach_financeiro,
expected_output='Um relatório categorizado dos gastos e sugestões para otimização financeira.'
)
# Criando uma equipe de agentes
time_crew = Crew(
agents=[coach_financeiro],
tasks=[analise_tarefa]
)
dados_gastos = {
"Alimentação": "R$ 2,500.00",
"Moradia": "R$ 3,000.00",
"Transporte": "R$ 800.00",
"Lazer": "R$ 1,200.00"
}
# 4. Executando o trabalho
resultado = time_financeiro.kickoff(inputs={'gastos': dados_gastos})
print(resultado)Com poucas linhas de código, eu tinha um fluxo de trabalho organizado. A empolgação foi tanta que tentei aplicar isso ao meu projeto de análise de ações. E foi aí que encontrei meu primeiro grande obstáculo.
Um Tropeço e uma Lição: Tokens e Alucinações
Ao tentar passar históricos de anos de uma ação e dezenas de artigos para a IA analisar, duas coisas aconteceram:
1. Custo: O consumo de tokens foi para as alturas, tornando cada análise cara.
2. Alucinações: As respostas vinham inconsistentes. A IA "viajava", inventava dados ou se perdia no meio de tanta informação.
Frustrado, comentei sobre isso com outro colega, que me deu a dica mais valiosa de toda essa jornada:
Tente passar os resultados mais mastigados para a IA. Ela é uma ótima analista, não uma processadora de dados brutos.
Essa foi a virada de chave. Em vez de pedir para a IA analisar um oceano de dados, eu deveria usar as ferramentas certas para cada trabalho:
A IA deveria receber apenas o resumo consolidado desses dados. A lição é clara:
dê o sapato ao sapateiro.
Deixe o código fazer o trabalho pesado de processamento e a IA fazer o que ela faz de melhor: interpretar, conectar ideias e gerar insights.
# 1. Inicialização
symbols = ['AAPL', 'GOOGL', 'MSFT']
retriever = StockDataRetriever(symbols, timeframe='1mo')
# 2. Criar agentes
sentiment_agent = create_sentiment_agent()
financial_agent = create_financial_agent()
analyst_agent = create_analyst_agent()
# 3. Criar tarefas
tasks = create_tasks(
sentiment_agent,
financial_agent,
analyst_agent,
retriever,
symbols
)
# 4. Obter análises
data = retriever.retrieve_all_data()
news_analyzer = NewsAnalyzer()
financial_analyzer = FinancialAnalyzer()
sentiment_results = news_analyzer.analyze_sentiment(data['news_data'])
financial_results = financial_analyzer.analyze_financial_data(data['financial_data'])
# 5. Visualizar resultados
for symbol in symbols:
plot_stock_data(data['financial_data'][symbol], symbol)Nesta etapa ja tinha ficado bom mas ainda tinha muita escrita de código junto aos prompts
Passo 4: Simplificando a Criação de Ferramentas com Agno
Seguindo a lição, meu fluxo ficou muito mais robusto. Eu tinha scripts para análise técnica, de sentimento e fundamentalista, que geravam resumos e passavam para a IA. O próximo desafio era integrar essas "ferramentas" de forma ainda mais fácil.
Foi aí que conheci o Agno, um framework mais recente, projetado para ser extremamente amigável ao desenvolvedor Python. O Agno facilita a criação de Tools e a organização de agentes em Teams.
Com ele, pude definir meus agentes e suas ferramentas de forma muito declarativa:
Exemplo básico para análise financeira
from agno.agent import Agent
from agno.team.team import Team
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.yfinance import YFinanceTools
# Agente especialista em buscar notícias na web
web_agent = Agent(
name="Web Agent",
role="Pesquisador de notícias financeiras",
model=OpenAIChat(id="gpt-4o"),
tools=[DuckDuckGoTools()],
instructions="Busque as notícias mais recentes e relevantes sobre o ativo em questão, citando as fontes."
)
# Agente especialista em buscar dados financeiros
finance_agent = Agent(
name="Finance Agent",
role="Analista de dados de mercado",
model=OpenAIChat(id="gpt-4o"),
tools=[YFinanceTools()],
instructions="Obtenha dados financeiros como P/L, preço atual e recomendações de analistas. Apresente em tabelas."
)
# O time que orquestra tudo
agent_team = Team(
members=[web_agent, finance_agent],
model=OpenAIChat(id="gpt-4o"),
instructions="Você é o editor-chefe. Coordene os agentes para criar um relatório completo sobre um ativo financeiro, unindo dados e notícias."
)
# Executando a análise
agent_team.print_response(
input="Faça um resumo das recomendações de analistas e últimas notícias sobre NVDA",
stream=True,
)Criei um código que:
1 Análise Quantitativa
Métricas Fundamentalistas
Análise Técnica
2 Análise Setorial
3 Geração de Relatórios
Exemplo de código Agents trabalhando em Team
from textwrap import dedent
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.team.team import Team
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.yfinance import YFinanceTools
web_agent = Agent(
name="Web Agent",
role="Search the web for information",
model=OpenAIChat(id="gpt-4o"),
tools=[DuckDuckGoTools()],
instructions=dedent("""
Você é um pesquisador de notícias financeiras! 🔍
Orientações:
1. Sempre busque as fontes mais recentes e relevantes
2. Cruzar informações de múltiplas fontes
3. Priorizar sites de notícias confiáveis
4. Cite as fontes com links
5. Destaque fatos relevantes e impacto de mercado
Estilo:
- Notícias em formato jornalístico, direto e claro
- Bullet points para tópicos-chave
- Indicar sentimento de mercado e tendências com emojis
- Sempre especifique data e hora das notícias selecionadas
"""),
markdown=True,
)
finance_agent = Agent(
name="Finance Agent",
role="Get financial data",
model=OpenAIChat(id="gpt-4o"),
tools=[YFinanceTools()],
instructions=dedent("""
Você é um analista financeiro especializado em dados do mercado! 📊
Fluxo:
1. Visão de mercado (preço, variação, faixa 52 semanas)
2. Mergulho financeiro (P/E, Market Cap, EPS)
3. Opinião de analistas (recomendações/revisões)
4. Contexto setorial e concorrência
5. Indicadores e tendências de sentimento do mercado
Estilo:
- Comece com resumo executivo
- Utilize tabelas para exibir dados
- Claro uso de bullet points
- Emojis 📈📉 para tendências
- Compare com médias do setor
- Termine com análise prospectiva e disclaimer de risco
"""),
add_datetime_to_context=True,
markdown=True,
)
agent_team = Team(
members=[web_agent, finance_agent],
model=OpenAIChat(id="gpt-4o"),
instructions=dedent("""
Você é o editor-chefe da mesa de notícias financeiras!
Tarefas:
1. Coordenar o pesquisador web e o analista financeiro
2. Unir os achados em um relatório único e lógico
3. Garantir fontes, clareza e visão balanceada dados/notícias
Estilo:
- Manchete destacada, seguida por resumo executivo
- Dados financeiros primeiro, depois contexto de notícias
- Use seções bem marcadas, tabelas, e 'Key Takeaways'
- Termine com 'Market Sentiment' e 'Fatores de Risco' atuais
- Assine como 'Market Watch Team' + data/hora
"""),
add_datetime_to_context=True,
markdown=True,
show_members_responses=False,
)
# Exemplos de uso detalhados:
agent_team.print_response(
input="Resumo das recomendações de analistas e últimas notícias sobre NVDA",
stream=True,
)
agent_team.print_response(
input=dedent("""
Qual o desempenho de mercado e perspectivas financeiras das empresas de semicondutores de IA?
Compare: NVIDIA (NVDA), AMD (AMD), Intel (INTC), Taiwan Semiconductor (TSM).
"""),
stream=True,
)
agent_team.print_response(
input=dedent("""
Analise os recentes desdobramentos e o desempenho financeiro da TSLA.
"""),
stream=True,
)O resultado foi um relatório incrivelmente completo, gerado de forma autônoma, economizando um tempo enorme de pesquisa manual.
A Reviravolta Final: E se Tudo Fosse Apenas um Prompt?
Depois de toda essa jornada, descobri uma ferramenta que me fez repensar tudo: o Perplexity Tasks. Ele permite que você crie um prompt detalhado e o agende para ser executado recorrentemente.
Eu peguei todo o aprendizado sobre o que um bom analista financeiro faria (análise de valor, de momentum, indicadores, etc.) e compilei em um único prompt.
Atue como um analista financeiro especialista no mercado brasileiro e pesquisador quantitativo.
Forneça duas análises abrangentes baseadas em ações da B3, com valores expressos em Reais (R$):
(1) Análise de Filtragem de Valor e (2) Análise de Momentum.
(1) Análise de Filtragem de Valor:
Identifique pelo menos 10 ações brasileiras de grande capitalização (valor de mercado > R$10 bilhões) que estão atualmente sendo negociadas dentro de 10% das suas mínimas de 52 semanas e que apresentam relação Preço/Lucro (P/L) trailing ≤10.
Para cada ação, forneça:
Preço atual (R$)
Mínima de 52 semanas (R$)
Relação P/L (trailing)
Classificação setorial (de acordo com a classificação da B3)
(2) Análise de Momentum:
Liste as 10 ações de grande capitalização com melhor desempenho nos últimos 5 pregões.
Para cada ação, inclua:
Indicadores de Momentum: ROC de 14 dias e 21 dias
Osciladores Técnicos: RSI de 14 dias, com sinal de sobrecompra/sobrevenda
Validação de Tendência: posição atual em relação às médias móveis de 20, 50 e 200 períodos
Análise de Correlação: como o momentum atual se alinha com padrões históricos de desempenho da ação
Perspectiva de curto prazo (1-2 semanas): avaliação da probabilidade de continuidade da tendência com base na confluência técnica dos indicadores
Requisitos adicionais:
Excluir ações com preço inferior a R$5
Focar em ações com volume médio diário superior a 500 mil papéis
Destacar qualquer ação que apareça em ambas as análises (valor + momentum)
Incluir avaliação de risco para cada recomendação (baixo, moderado ou alto), com base em volatilidade histórica, liquidez e exposição setorialO resultado? Surpreendentemente bom. O Perplexity usou sua própria capacidade de busca e análise para gerar relatórios, tabelas e até gráficos, com uma qualidade muito parecida com a do meu complexo sistema de agentes.
Exemplo de imagens geradas
Conclusão: Qual o Melhor Caminho?
Essa jornada foi um aprendizado imenso. Comecei com um script simples, evoluí para uma arquitetura complexa de agentes e terminei com um prompt que fazia quase tudo.
Então, o que aprendemos com isso?
1. Comece Simples: Não tente construir um sistema complexo de uma vez. Comece com um script para validar sua ideia.
2. Pré-processe os Dados: Não jogue dados brutos na IA. Use código para limpar, resumir e extrair as informações mais importantes. Deixe a IA brilhar na análise.
3. Use Frameworks para Orquestrar: Ferramentas como CrewAI e Agno são fantásticas para organizar projetos maiores, economizando tempo e dores de cabeça. O Agno, em particular, se mostrou incrivelmente fácil de usar.
4. Nunca Subestime um Bom Prompt: Para muitas tarefas, uma ferramenta como o Perplexity combinada com um prompt extremamente detalhado pode oferecer 80% do resultado com 20% do esforço.
5. Analise de sentimento não funciona bem: O preço dos ativos não reflete a analise do sentimentos das noticias quando aparecem. Os ativos ja estão precificados. Exemplo se esta semana a analise da Petrobras PETR4 deram como negativa o preço costuma oscilar bem antes. Então as noticias são atrasadas.
No fim, não existe uma única ferramenta "certa". A escolha depende do seu objetivo, do nível de controle que você precisa e do seu tempo. Para meu uso pessoal, o resultado com o prompt agendado foi mais que satisfatório.
A melhor dica que posso dar é: teste,teste bastante , experimente e continue aprendendo. O campo está se movendo rápido, e a melhor forma de se manter relevante é colocando a mão na massa.
No fim consegui um resultado satisfatório
