Hedge Fund com Inteligência Artificial: Entenda Como Funciona

Um repositório simula um hedge fund com IA, onde agentes de IA, cada um representando a estratégia de investimento de um investidor famoso, analisam dados financeiros e tomam decisões de negociação. O sistema inclui ferramentas para testar essas estratégias. É importante notar que este é um conceito e é destinado apenas para fins educacionais e de pesquisa.

O sistema incorpora ferramentas para backtesting dessas estratégias. É importante notar que esta é uma prova de conceito e se destina apenas para fins educacionais e de pesquisa.

Módulos do sistema

• src/agents: Contém as definições para cada agente de investimento (por exemplo, Warren Buffett, Cathie Wood) e sua lógica específica para analisar ações e gerar sinais de negociação.
• src/tools: Define ferramentas usadas pelos agentes, principalmente chamadas de API para buscar dados financeiros.
• src/llm: Gerencia a configuração e instanciação de Large Language Models (LLMs) de diferentes provedores (OpenAI, Groq, etc.).
• src/graph: Define a estrutura do fluxo de trabalho do agente.
• src/utils: Fornece funções de utilidade para tarefas como exibir informações, gerenciar o progresso e interagir com LLMs.
• src/data: Inclui modelos de dados (usando Pydantic) e um mecanismo de cache para respostas da API.
• src/backtester.py: Implementa a funcionalidade de backtesting para avaliar o desempenho do hedge fund com IA em dados históricos.
• src/main.py: Serve como o ponto de entrada principal para executar o hedge fund com IA.

Estrutura do código

Seção 1: Definições de Agentes (src/agents)

Esta seção define a lógica central do hedge fund com IA: os agentes de investimento. Cada agente é responsável por analisar ações com base em uma filosofia de investimento específica.

• Classes/Arquivos-chave:

  • Cada arquivo (por exemplo, warren_buffett.py, cathie_wood.py) define um único agente.
  • Cada função de agente recebe o AgentState atual como entrada e retorna um AgentState atualizado.
  • Os agentes usam o módulo tools.api para buscar dados financeiros.
  • Os agentes usam LLMs de llm.models para gerar sinais de investimento com base em sua análise.
  • Os agentes geram um sinal de negociação (otimista, pessimista ou neutro) com um nível de confiança e raciocínio.

• Fluxo de trabalho:

1. Busca de dados: Os agentes recuperam dados financeiros usando funções de src/tools/api.py. Isso inclui métricas financeiras, itens de linha, negociações de insiders e notícias da empresa.
2. Análise: Os agentes aplicam suas estratégias de investimento específicas aos dados buscados. Isso geralmente envolve o cálculo de índices financeiros, a análise de tendências e a avaliação do sentimento do mercado.
3. Raciocínio (LLM): Muitos agentes utilizam LLMs para sintetizar sua análise e gerar um sinal de investimento bem fundamentado. A engenharia de prompt dentro desses agentes é crucial para orientar o processo de tomada de decisão do LLM.
4. Geração de sinal: Cada agente gera um sinal de negociação (otimista, pessimista ou neutro), juntamente com um nível de confiança e uma explicação textual de seu raciocínio.

• Funções-chave:

  • warren_buffett_agent(state: AgentState): Exemplo de uma função de agente.
  • generate_buffett_output(...): Exemplo de função que usa LLM para gerar decisões de investimento.
  • analyze_fundamentals(...): Exemplo de função que analisa os fundamentos da empresa com base nos critérios de Buffett.

• Uso de LLMs:

  • Os agentes usam LLMs para fornecer raciocínio semelhante ao humano para suas decisões de investimento. A qualidade da saída do LLM depende muito dos prompts fornecidos a ele, que são projetados para orientar o LLM na emulação do estilo de investimento do investidor específico.
  • O arquivo llm.py contém a função call_llm, que simplifica o processo de chamar um LLM, lidar com erros e analisar a saída do LLM em um modelo Pydantic. Esta função é usada em vários agentes.

Seção 2: Tratamento de Dados (src/data) e Chamadas de API (src/tools)

Esta seção se concentra em como o sistema recupera e gerencia dados financeiros.

• Classes/Arquivos-chave:

  • src/data/models.py: Define modelos Pydantic para representar dados financeiros (por exemplo, Price, FinancialMetrics, CompanyNews).
  • src/data/cache.py: Implementa um cache na memória para armazenar respostas da API e reduzir o número de chamadas de API externas.
  • src/tools/api.py: Fornece funções para buscar dados financeiros da API FinancialDatasets.

• Fluxo de trabalho:

1. Chamadas de API: O módulo src/tools/api.py faz chamadas à API FinancialDatasets para recuperar dados financeiros. Ele constrói os URLs apropriados e lida com a autenticação da API usando uma chave de API armazenada em variáveis de ambiente.
2. Modelagem de dados: As respostas da API são analisadas usando modelos Pydantic definidos em src/data/models.py. Isso garante a consistência dos dados e a segurança do tipo.
3. Cache: O módulo src/data/cache.py fornece um cache na memória para armazenar respostas da API. Antes de fazer uma chamada de API, o sistema verifica o cache para os dados solicitados. Se os dados forem encontrados no cache e ainda forem válidos, eles serão usados diretamente, evitando a necessidade de uma chamada de API externa.

• Funções-chave:

  • get_prices(ticker: str, start_date: str, end_date: str): Busca dados de preços para um determinado ticker dentro de um intervalo de datas especificado.
  • get_financial_metrics(ticker: str, end_date: str, period: str = "ttm", limit: int = 10): Recupera métricas financeiras para um determinado ticker.
  • get_insider_trades(ticker: str, end_date: str, start_date: str | None = None, limit: int = 1000): Recupera dados de negociação de insiders para um determinado ticker.
  • get_company_news(ticker: str, end_date: str, start_date: str | None = None, limit: int = 1000): Recupera artigos de notícias da empresa para um determinado ticker.

• Chamadas de API externas:

  • API FinancialDatasets: Usada para recuperar dados financeiros, incluindo preços de ações, métricas financeiras, negociações de insiders e notícias da empresa.

Seção 3: Gerenciamento de LLM (src/llm)

Esta seção lida com a configuração e instanciação de Large Language Models (LLMs) de diferentes provedores.

• Classes/Arquivos-chave:

  • src/llm/models.py: Define os LLMs disponíveis, seus provedores e funções de utilidade para interagir com eles.

• Fluxo de trabalho:

1. Definição do modelo: O arquivo src/llm/models.py define os LLMs disponíveis e seus provedores usando a classe LLMModel.
2. Instanciação do modelo: A função get_model(model_name: str, model_provider: ModelProvider) instancia um LLM do provedor especificado usando a chave de API apropriada armazenada em variáveis de ambiente.
3. Interação LLM: A função call_llm em src/utils/llm.py simplifica o processo de chamar um LLM, lidar com erros e analisar a saída do LLM em um modelo Pydantic.

• Funções-chave:
  • get_model(model_name: str, model_provider: ModelProvider): Instancia um LLM do provedor especificado.
  • call_llm(prompt: Any, model_name: str, model_provider: str, pydantic_model: Type[T], agent_name: Optional[str] = None, max_retries: int = 3, default_factory = None): Simplifica o processo de chamar um LLM, lidar com erros e analisar a saída do LLM em um modelo Pydantic.

Seção 4: Gerenciamento de Fluxo de Trabalho (src/graph)

Esta seção define a estrutura do fluxo de trabalho do agente usando LangGraph.

• Classes/Arquivos-chave:

  • src/graph/state.py: Define a classe AgentState, que representa o estado do fluxo de trabalho do agente.
  • src/main.py: Cria o fluxo de trabalho LangGraph.

• Fluxo de trabalho:

1. Definição de estado: A classe AgentState em src/graph/state.py define os dados que são passados entre os agentes no fluxo de trabalho. Isso inclui a lista de mensagens, o dicionário de dados e os metadados.
2. Criação do fluxo de trabalho: A função create_workflow(selected_analysts=None) em src/main.py cria o fluxo de trabalho LangGraph. Isso envolve adicionar nós para cada agente selecionado, bem como nós para gerenciamento de risco e gerenciamento de portfólio.
3. Execução do fluxo de trabalho: A função run_hedge_fund em src/main.py executa o fluxo de trabalho LangGraph. Isso envolve invocar o aplicativo LangGraph compilado com o estado inicial e, em seguida, iterar sobre as mensagens resultantes.

• Funções-chave:
  • create_workflow(selected_analysts=None): Cria o fluxo de trabalho LangGraph.
  • run_hedge_fund(...): Executa o fluxo de trabalho LangGraph.

Seção 5: Backtesting (src/backtester.py) e Execução Principal (src/main.py)

Esta seção cobre a funcionalidade de backtesting e o ponto de entrada principal para executar o hedge fund com IA.

• Classes/Arquivos-chave:

  • src/backtester.py: Implementa a funcionalidade de backtesting.
  • src/main.py: Serve como o ponto de entrada principal para executar o hedge fund com IA.

• Fluxo de trabalho:

1. Backtesting: A classe Backtester em src/backtester.py simula a execução do hedge fund com IA em dados históricos. Ele itera sobre um intervalo de datas, busca dados históricos, executa negociações com base nas decisões do agente e rastreia o desempenho do portfólio.
2. Execução Principal: O arquivo src/main.py analisa os argumentos da linha de comando, solicita a entrada do usuário (por exemplo, tickers, analistas, modelo), cria o fluxo de trabalho LangGraph e executa o hedge fund com IA.

• Funções-chave:
  • Backtester.run_backtest(): Executa a simulação de backtesting.
  • run_hedge_fund(...): Executa o hedge fund com IA.

Esquema do BD

Não há um esquema de banco de dados explícito definido, pois o sistema usa a API FinancialDatasets para recuperação de dados e um cache na memória para armazenamento temporário.

Chamadas de API externas

• API FinancialDatasets: Esta API é usada para recuperar dados financeiros, incluindo:
  • Preços de ações (/prices/)
  • Métricas financeiras (/financial-metrics/)
  • Negociações de insiders (/insider-trades/)
  • Notícias da empresa (/news/)
  • Pesquisa por itens de linha (/financials/search/line-items)

Insights

• Design Modular: A base de código é bem organizada em módulos, cada um com uma responsabilidade específica. Isso torna o código mais fácil de entender, manter e estender.
• Arquitetura Baseada em Agentes: O uso de agentes independentes, cada um com sua própria estratégia de investimento, permite um sistema flexível e extensível. Novos agentes podem ser facilmente adicionados ao sistema para incorporar diferentes filosofias de investimento.
• Integração de LLM: A integração de LLMs no processo de tomada de decisão dos agentes é um recurso-chave deste projeto. Os LLMs fornecem raciocínio e explicações semelhantes aos humanos para as decisões de investimento dos agentes.
• Cache: O cache na memória ajuda a reduzir o número de chamadas de API externas e melhora o desempenho do sistema.
• Backtesting: A funcionalidade de backtesting permite avaliar o desempenho do hedge fund com IA em dados históricos. Isso é crucial para validar a eficácia das estratégias de investimento.
• Rastreamento de Progresso: O módulo src/utils/progress.py fornece um mecanismo para rastrear o progresso dos agentes, fornecendo insights valiosos sobre a operação do sistema.

Experiências de Design

• Customização do Agente: O sistema permite que os usuários selecionem quais agentes incluir no fluxo de trabalho. Isso permite que os usuários personalizem o hedge fund com IA de acordo com suas preferências de investimento específicas.
• Flexibilidade: O design modular e a arquitetura baseada em agentes tornam o sistema altamente flexível e extensível. Novos agentes, fontes de dados e estratégias de negociação podem ser facilmente adicionados ao sistema.

Criatividade

• Emulando Investidores Famosos: O conceito de criar agentes de IA que emulam os estilos de investimento de investidores famosos é uma abordagem inovadora e envolvente para explorar o uso de IA em finanças.
• LangGraph: O uso de LangGraph para orquestrar o fluxo de trabalho do agente fornece uma maneira estruturada e flexível de gerenciar as interações entre os agentes.

Github Repo: AI-Powered Hedge Fund

Este conteúdo foi auxiliado por Inteligência Artificiado, mas escrito e revisado por um humano.