Por que Analisar o Mercado Bitcoin com Agentes de IA?

O cenário do bitcoin sempre foi meio intrigante. Foi lançado há 16 anos mas até hoje ninguém sabe ao certo quem está por trás do projeto — o criador, conhecido apenas pelo pseudônimo Satoshi Nakamoto, nunca revelou sua identidade. Além disso o bitcoin foi a primeira e ainda é a mais conhecida aplicação da tecnologia Blockchain, que revolucionou a forma como lidamos com registros digitais e segurança dos dados. Sua natureza descentralizada e sua notória volatilidade o tornam um ativo único.

Quem não se lembra da história das pizzas compradas por 10.000 BTC, que hoje valeriam uma fortuna? Mesmo que variações dessa magnitude sejam improváveis, eventos programados como o Halving – que reduz pela metade a emissão de novas moedas a cada quatro anos, simulando a escassez de metais preciosos – continuam a impactar significativamente sua oferta e, historicamente, seu preço.

Mas como saber o momento certo de comprar ou vender? A resposta não é simples. O preço do Bitcoin é influenciado por uma miríade de fatores: dados on-chain (movimentações na própria blockchain), o cenário macroeconômico global (inflação, taxas de juros), o sentimento do mercado e a análise técnica tradicional (padrões gráficos e indicadores). Analisar isoladamente qualquer um desses aspectos oferece uma visão incompleta. A verdadeira compreensão exige uma abordagem holística, combinando diferentes perspectivas.

Foi pensando nisso, e inspirado pelos recentes avanços em modelos de linguagem grandes (LLMs) e frameworks de agentes, que surgiu a ideia: E se eu delegar essa tarefa repetitiva e complexa a uma equipe de assistentes de IA? E se a IA pudesse não apenas coletar e analisar os dados, mas também interpretar o cenário e sugerir ações alinhadas a uma estratégia de investimento de longo prazo, como a acumulação gradual de Bitcoin?

É aqui que entram os Agentes de IA. Pense neles como sistemas autônomos que utilizam um LLM (como os modelos GPT da OpenAI) como seu “cérebro” ou motor de raciocínio. Eles podem interagir com ferramentas, processar informações e tomar decisões para atingir um objetivo específico. Em nosso caso, o objetivo será fornecer uma análise de mercado inteligente e automatizada, transformando dados brutos em insights acionáveis de alto nível.

Arquitetura da Solução: Uma Equipe de Agentes de IA Generativa

Em vez de um único agente monolítico tentando fazer tudo, o trabalho foi dividido em etapas lógicas, cada uma atribuída a um agente com um papel bem definido. Essa abordagem modular não só organiza melhor o processo, mas também facilita a manutenção e a evolução de cada componente:

• Data Fetcher: Coleta dados brutos de diversas APIs (cotações, on-chain, macro, técnicos).
• Data Analyst: Interpreta os dados brutos e gera um relatório técnico formatado.
• Market Strategist: Sintetiza a análise técnica, identifica tendências e gera recomendações táticas.
• Client Manager: Avalia a estratégia sob a ótica do objetivo do “cliente” (acumulação de longo prazo) e decide se um alerta é necessário.

Esses agentes utilizam tools (funções Python) para acessar APIs como Blockchain.com, Yahoo Finance, CoinGecko, FRED, etc. A orquestração é feita com o GitHub Actions que aciona a execução de todo o fluxo de trabalho todo dia - a cada 4 horas - executando o projeto que foi todo escrito em Python, LangChain (para os blocos de construção dos agentes), LangGraph (para o fluxo de trabalho), usando GPT-4o-mini como motor de raciocínio, Telegram como um canal para envio de alertas e LangSmith para monitoramento e depuração de cada passo da execução dos agentes.

📌 Clique aqui para ler meu post sobre como criar bots no Telegram.

Construindo o Workflow com LangGraph

Para orquestrar a interação entre os agentes de forma robusta, foi utilizado o LangGraph, uma biblioteca sobre o LangChain para criar aplicações LLM stateful e com múltiplos atores. Ele permite definir fluxos de trabalho como grafos, controlando explicitamente a sequência e permitindo futuras ramificações ou ciclos.

Montar o grafo envolve definir o estado compartilhado, adicionar os nós e conectar as arestas. LangGraph oferece diferentes maneiras de definir essa estrutura. Abaixo, tem um exemplo conceitual usando tanto a a GraphAPI, que é bastante explícita, quanto a Functional API, que é mais direta ao ponto:

from langgraph.graph import StateGraph, START, END
from typing_extensions import TypedDict

# Definir o Estado do Grafo
class State(TypedDict):
    topic: str # Input do Data Fetcher
    raw_data: str # Saída do Data Fetcher
    analysis_report: str # Saída do Data Analyst
    strategy_synthesis: str # Saída do Market Strategist
    manager_decision: str # Saída do Client Manager

# Definir os Nós (Agentes/Funções)
# Supondo que as funções já foram definidas
def data_fetcher(state: State):
    # ... 
    return {"raw_data": "dados coletados..."}

def data_analyst(state: State): ...
def market_strategist(state: State): ...
def client_manager(state: State): ...
def send_telegram_message(message_body): ...

# Construir o Grafo
workflow = StateGraph(State)

# Adicionar os nós
workflow.add_node("fetcher", data_fetcher)
workflow.add_node("analyst", data_analyst)
workflow.add_node("strategist", market_strategist)
workflow.add_node("manager", client_manager)

# Definir Arestas (o fluxo sequencial)
workflow.add_edge(START, "fetcher")
workflow.add_edge("fetcher", "analyst")
workflow.add_edge("analyst", "strategist")
workflow.add_conditional_edges("strategist", manager_decision, {
  "ALERTAR_CLIENTE": "send_telegram_message",
  "NAO_ALERTAR": END
  })

# Compilar o grafo em um objeto executável
chain = workflow.compile()

# Executar (exemplo)
state = chain.invoke({"topic": "btc"})

from langgraph.func import entrypoint, task

# Tasks/Agents

@task
def data_fetcher(topic: str) -> dict: ...
  
@task 
def data_analyst(state: State): ...

@task
def market_strategist(state: State): ...

@task
def client_manager(state: State): ...

def plot_btc_analysis(message_body): ...
def send_telegram_photo(message_body): ...
def send_telegram_message(message_body): ...

# Exemplo conceitual com abordagem funcional (usando decoradores)
@entrypoint()
def chaining_workflow(topic: str):
    data_fetched = data_fetcher(topic).result()
    analyst_report = data_analyst(data_fetched).result()
    strategist_report = market_strategist(analyst_report).result()
    
    if 'ALERTAR' in client_manager(strategist_report).result():
        fig = plot_btc_analysis()
        asyncio.run(send_telegram_photo(fig))
        asyncio.run(send_telegram_message(strategist_report))
        return "Entrar em contato"
    return "Não entrar em contato"

def run_chaining_workflow(topic: str, stream_mode: str = "updates"):
    return chaining_workflow.stream(topic, stream_mode=stream_mode)

# Invoke
logger.info("Iniciando o workflow...\n")
for step in run_chaining_workflow("", stream_mode="updates"):
    for key, value in step.items():
        logger.info(f"[ {key} ]\n{'=' * 80}\n{value}\n")
logger.info("Workflow finalizado.")

Este controle fino do fluxo, seja pela API explícita ou por abordagens mais funcionais, é uma das grandes vantagens do LangGraph para sistemas multi-agentes, que ainda permite uma integração com o LangSmith para acompanhamento detalhado do fluxo de “raciocínio” dos agentes. Para mais detalhes, consulte a documentação oficial.

Mergulhando nos Agentes: Prompts e Ferramentas

Vamos ver rapidamente como cada agente funciona, focando nos prompts e ferramentas:

from pydantic import BaseModel, Field
from langchain.schema.messages import HumanMessage, ToolMessage
from langgraph.func import task
from langchain_openai import ChatOpenAI

from tools.fetch_data_btc import fetch_data_btc
from tools.fetch_data_onchain import fetch_data_onchain
from tools.fetch_data_macroeconomic import fetch_data_macroeconomic
from tools.fetch_data_market import fetch_data_market
from tools.fetch_data_tecnical import fetch_data_tecnical

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

@task
def data_fetcher(topic: str):
  
  class StructuredJsonOutput(BaseModel):
    btc_data: str = Field(None, description="Bitcoin data and USD to BRL exchange rate")
    onchain_data: str = Field(None, description="On-chain Bitcoin data")
    macroeconomic_data: str = Field(None, description="Macroeconomic data")
    market_data: str = Field(None, description="Market sentiment and Bitcoin-related metrics")
    tecnical_data: str = Field(None, description="technical analysis indicators for Bitcoin")

  structured_llm = llm.with_structured_output(StructuredJsonOutput)

  instructions = "Você é um pesquisador responsável por coletar dados de diferentes fontes sobre o mercado de Bitcoin e gerar um output no formato json."

  tools = [
      fetch_data_btc,
      fetch_data_onchain,
      fetch_data_macroeconomic,
      fetch_data_market,
      fetch_data_tecnical
      ]

  tools_by_name = {tool.name: tool for tool in tools}

  llm_with_tools = llm.bind_tools(tools)

  messages = [HumanMessage(instructions)]
  ai_msg = llm_with_tools.invoke(messages)
  messages.append(ai_msg)

  for tool_call in ai_msg.tool_calls:
      selected_tool = tools_by_name[tool_call["name"].lower()]
      tool_output = selected_tool.invoke(tool_call["args"])
      messages.append(ToolMessage(tool_output, tool_call_id=tool_call["id"]))

  messages.append(structured_llm.invoke(messages))

  return messages[-1].model_dump_json(indent=3)

from langgraph.func import task
from langchain.prompts import ChatPromptTemplate, FewShotChatMessagePromptTemplate
from langchain_openai import ChatOpenAI

from prompts.data_analyst_example import input_example, output_example

llm = ChatOpenAI(model="gpt-4", temperature=0.7)

@task
def data_analyst(report: str):

  input = f"""
  Você é um analista financeiro experiente em Cryptomoedas e especialista em Bitcoin.
  Analise as tendências do cenário do Bitcoin hoje com base no json \
  delimitado por três crases (```):

  \```
  {report}
  \```

  Siga rigorosamente as instruções abaixo:

  - ...
  """

  examples = [
      {"input": input_example, "output": output_example},
       ]

  example_prompt = ChatPromptTemplate.from_messages([
      ("human", "{input}"),
      ("ai", "{output}"),
      ])

  few_shot_prompt = FewShotChatMessagePromptTemplate(
      example_prompt=example_prompt,
      examples=examples,
      )

  prompt_system = "Você é um analista financeiro experiente em Criptomoedas e especialista em Bitcoin."

  final_prompt = ChatPromptTemplate.from_messages([
    ("system", prompt_system),
    few_shot_prompt,
    ("human", "{input}"),
    ])

  chain = final_prompt | llm

  msg = chain.invoke(input=input)

  return msg.content

from langgraph.func import task
from langchain.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(temperature=0.7)

@task
def market_strategist(analyst_report: str):
    """
    Gera recomendações de posicionamento com base na análise do Data Analyst.
    """
  
    input = f"""
    Seu papel é analisar o relatório técnico fornecido no formatado em Markdown e transformar\
    em uma síntese estratégica e executiva, com alertas, insights e orientações táticas de alto nível.
  
    \``` markdown
    {analyst_report}
    \```
  
    Siga rigorosamente as instruções abaixo:
  
    - ...
    """
  
    prompt = ChatPromptTemplate.from_messages([
        ("system", "Você é um estrategista de mercado sênior, com ampla experiência em ativos digitais e especialização em Bitcoin."),
        ("human", "{input}")
    ])
  
    chain = prompt | llm
    msg = chain.invoke(input=input)
    return msg.content

from langgraph.func import task
from langchain.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(temperature=0.7)

@task
def client_manager(final_report: str):
    """
    Avalia o relatório estratégico e decide se deve ou não alertar o cliente.
    A decisão final é binária: ALERTAR_CLIENTE ou NÃO_ALERTAR.
    """

    input = f"""
    Objetivo do cliente: Acumular Bitcoins no longo prazo, investindo mensalmente nas melhores janelas de oportunidade.

    Seu papel é avaliar o relatório abaixo e decidir se há motivos suficientes para alertar o cliente:

    \``` markdown
    {final_report}
    \```

    Siga rigorosamente as instruções abaixo:

    - ...
    """

    prompt = ChatPromptTemplate.from_messages([
        ("system", "Você é um Client Manager, especializado em comunicação estratégica com clientes de alto valor."),
        ("human", "{input}")
    ])

    chain = prompt | llm
    msg = chain.invoke(input=input)
    return msg.content

Desafios, Aprendizados e Observabilidade

Construir agentes envolve desafios:

• Prompt Engineering: É uma arte iterativa. Clareza, exemplos (Few-Shot) e estrutura são essenciais.
• Orquestração (LangGraph): Gerenciar o estado e o fluxo entre nós exige atenção.
• Integração de Ferramentas: Descrições claras das tools são vitais para o LLM usá-las corretamente.
• Observabilidade: Identificar falhas em fluxos complexos pode ser difícil.

Ferramentas como o LangSmith são extremamente úteis na monitoramento dos agentes, permitindo rastrear e depurar cada passo de sua execução, chamadas de LLM e uso de ferramentas. Ele oferece uma visão clara do que está acontecendo “por baixo dos panos”, facilitando a identificação de gargalos ou erros.

Conclusão

Criamos uma equipe de agentes IA capaz de automatizar a complexa análise do mercado Bitcoin, usando LangChain e LangGraph para orquestração. O sistema coleta dados, interpreta, gera estratégias e decide sobre alertas, transformando dados brutos em insights acionáveis. Veja como é o alerta recebido no Telegram:

Print das telas do bot no Telegram.

Este projeto demonstra o potencial dos agentes para automatizar tarefas repetitivas que envolvem a tomada de decisões com um certo “raciocínio”. Os próximos passos podem envolver refinar prompts, adicionar mais ferramentas, integrar mais visualizações ou implementar notificações ativas.

Referências

• LangChain - Documentação
• LangGraph - Documentação
• LangSmith - Documentação
• OpenAI API Plataform
• OpenAI - Prompt Engineering Guide
• OpenAI - A Practical Guide to Building Agents
• LangGraph Tutorial - Building Agentic Workflows
• LangChain Blog - How to think about agent frameworks