Exemplos Práticos

Implementações completas e casos de uso do NeuroChart.ai.

Exemplo 1: Bot de Trading Simples

Python

import neurochart
import time

class SimpleTrader:
    def __init__(self, api_key):
        self.client = neurochart.Client(api_key)
        self.position = None
        
    def analyze_market(self):
        """Analisa o mercado usando Chart GPT V3 TURBO"""
        response = self.client.chat.complete({
            'messages': [{
                'role': 'user',
                'content': 'Analise BTC/USDT para day trading. Devo comprar, vender ou aguardar?'
            }]
        })
        
        return response.choices[0].message.content
        
    def execute_trade(self):
        analysis = self.analyze_market()
        
        if 'comprar' in analysis.lower() and not self.position:
            print(f"🟢 Sinal de COMPRA detectado")
            self.position = {
                'side': 'buy',
                'price': self.get_current_price(),
                'time': time.time()
            }
        elif 'vender' in analysis.lower() and self.position:
            print(f"🔴 Sinal de VENDA detectado")
            profit = self.calculate_profit()
            print(f"💰 Lucro: {profit}%")
            self.position = None
            
    def get_current_price(self):
        ticker = self.client.market.ticker('BTCUSDT')
        return float(ticker['price'])
        
    def calculate_profit(self):
        current_price = self.get_current_price()
        entry_price = self.position['price']
        return ((current_price - entry_price) / entry_price) * 100

# Uso
trader = SimpleTrader('your_api_key')
while True:
    trader.execute_trade()
    time.sleep(300)  # Aguarda 5 minutos

Exemplo 2: Dashboard React

Component de Análise em Tempo Real

import React, { useState, useEffect } from 'react';
import { NeuroChart } from '@neurochart/sdk';

function CryptoAnalyzer() {
  const [analysis, setAnalysis] = useState(null);
  const [loading, setLoading] = useState(false);
  const [selectedCoin, setSelectedCoin] = useState('BTC');
  
  const nc = new NeuroChart({
    apiKey: process.env.REACT_APP_NEUROCHART_KEY
  });
  
  const analyzeMarket = async () => {
    setLoading(true);
    try {
      const response = await nc.chat.complete({
        messages: [{
          role: 'user',
          content: `Faça uma análise completa do ${selectedCoin} incluindo:
            1. Tendência atual
            2. Níveis importantes
            3. Indicadores técnicos
            4. Recomendação de trading`
        }]
      });
      
      setAnalysis(response.choices[0].message.content);
    } catch (error) {
      console.error('Erro na análise:', error);
    }
    setLoading(false);
  };
  
  useEffect(() => {
    analyzeMarket();
    const interval = setInterval(analyzeMarket, 60000); // Atualiza a cada minuto
    return () => clearInterval(interval);
  }, [selectedCoin]);
  
  return (
    <div className="analyzer-container">
      <div className="coin-selector">
        {['BTC', 'ETH', 'BNB', 'SOL'].map(coin => (
          <button 
            key={coin}
            onClick={() => setSelectedCoin(coin)}
            className={selectedCoin === coin ? 'active' : ''}
          >
            {coin}
          </button>
        ))}
      </div>
      
      <div className="analysis-panel">
        {loading ? (
          <div className="loading">Analisando mercado...</div>
        ) : (
          <div className="analysis-content">
            <h2>Análise {selectedCoin}/USDT</h2>
            <pre>{analysis}</pre>
          </div>
        )}
      </div>
      
      <button onClick={analyzeMarket} className="refresh-btn">
        🔄 Atualizar Análise
      </button>
    </div>
  );
}

export default CryptoAnalyzer;

Exemplo 3: Alertas Automáticos

Node.js + Express

const express = require('express');
const { NeuroChart } = require('@neurochart/sdk');

const app = express();
const nc = new NeuroChart({ apiKey: process.env.API_KEY });

// Configurar alertas
const alerts = [
  { coin: 'BTC', condition: 'RSI > 70', action: 'notify_overbought' },
  { coin: 'ETH', condition: 'MACD crossover', action: 'notify_buy_signal' }
];

// Verificar condições a cada 5 minutos
setInterval(async () => {
  for (const alert of alerts) {
    const analysis = await nc.analysis.technical({
      symbol: `${alert.coin}USDT`,
      indicators: ['RSI', 'MACD']
    });
    
    if (checkCondition(analysis, alert.condition)) {
      sendNotification(alert);
    }
  }
}, 300000);

function checkCondition(analysis, condition) {
  // Lógica para verificar condições
  if (condition.includes('RSI > 70')) {
    return analysis.rsi.value > 70;
  }
  // Adicionar mais condições...
}

function sendNotification(alert) {
  console.log(`🚨 Alerta: ${alert.coin} - ${alert.condition}`);
  // Implementar envio de email, SMS, etc.
}

app.listen(3000, () => {
  console.log('Sistema de alertas rodando na porta 3000');
});

Exemplo 4: Análise de Sentimento

Script de Monitoramento

from neurochart import Client
import matplotlib.pyplot as plt
from datetime import datetime, timedelta

client = Client('your_api_key')

def analyze_sentiment(coin, days=7):
    """Analisa o sentimento do mercado para uma moeda"""
    
    results = []
    
    for i in range(days):
        date = datetime.now() - timedelta(days=i)
        
        response = client.chat.complete({
            'messages': [{
                'role': 'user',
                'content': f'Qual o sentimento do mercado para {coin} em {date.strftime("%Y-%m-%d")}? Responda com: Muito Negativo, Negativo, Neutro, Positivo ou Muito Positivo.'
            }]
        })
        
        sentiment = response.choices[0].message.content
        results.append({
            'date': date,
            'sentiment': sentiment,
            'score': sentiment_to_score(sentiment)
        })
    
    return results

def sentiment_to_score(sentiment):
    mapping = {
        'Muito Negativo': -2,
        'Negativo': -1,
        'Neutro': 0,
        'Positivo': 1,
        'Muito Positivo': 2
    }
    return mapping.get(sentiment, 0)

def plot_sentiment(data, coin):
    dates = [d['date'] for d in data]
    scores = [d['score'] for d in data]
    
    plt.figure(figsize=(10, 6))
    plt.plot(dates, scores, marker='o')
    plt.axhline(y=0, color='gray', linestyle='--')
    plt.title(f'Sentimento do Mercado - {coin}')
    plt.xlabel('Data')
    plt.ylabel('Sentimento')
    plt.ylim(-2.5, 2.5)
    plt.grid(True, alpha=0.3)
    plt.show()

# Uso
btc_sentiment = analyze_sentiment('Bitcoin', days=14)
plot_sentiment(btc_sentiment, 'Bitcoin')

Exemplo 5: WebSocket em Tempo Real

Integração com Chart GPT

const WebSocket = require('ws');
const { NeuroChart } = require('@neurochart/sdk');

class RealTimeAnalyzer {
  constructor(apiKey) {
    this.nc = new NeuroChart({ apiKey });
    this.ws = null;
    this.analysisQueue = [];
  }
  
  connect() {
    this.ws = new WebSocket('wss://stream.binance.com:9443/ws/btcusdt@trade');
    
    this.ws.on('message', async (data) => {
      const trade = JSON.parse(data);
      
      // Acumula trades por 1 minuto
      this.analysisQueue.push(trade);
      
      if (this.analysisQueue.length >= 60) {
        await this.analyzePattern();
        this.analysisQueue = [];
      }
    });
  }
  
  async analyzePattern() {
    const prices = this.analysisQueue.map(t => parseFloat(t.p));
    const volumes = this.analysisQueue.map(t => parseFloat(t.q));
    
    const avgPrice = prices.reduce((a, b) => a + b) / prices.length;
    const totalVolume = volumes.reduce((a, b) => a + b);
    
    const response = await this.nc.chat.complete({
      messages: [{
        role: 'user',
        content: `Analise este padrão de trading:
          - Preço médio: ${avgPrice}
          - Volume total: ${totalVolume}
          - Variação: ${Math.max(...prices) - Math.min(...prices)}
          
          Isso indica acumulação, distribuição ou neutro?`
      }]
    });
    
    console.log('📊 Análise:', response.choices[0].message.content);
  }
}

// Iniciar análise
const analyzer = new RealTimeAnalyzer('your_api_key');
analyzer.connect();

Exemplo 6: Backtesting de Estratégias

Testando Estratégias com Dados Históricos

import neurochart
import pandas as pd
from datetime import datetime, timedelta

class StrategyBacktest:
    def __init__(self, api_key):
        self.client = neurochart.Client(api_key)
        self.results = []
        
    def test_strategy(self, symbol, start_date, end_date):
        """Testa uma estratégia baseada em IA"""
        current_date = start_date
        capital = 10000
        position = None
        
        while current_date <= end_date:
            # Simula análise do Chart GPT
            signal = self.get_ai_signal(symbol, current_date)
            price = self.get_historical_price(symbol, current_date)
            
            if signal == 'BUY' and not position:
                position = {
                    'entry_price': price,
                    'entry_date': current_date,
                    'size': capital / price
                }
            elif signal == 'SELL' and position:
                profit = (price - position['entry_price']) * position['size']
                capital += profit
                
                self.results.append({
                    'entry_date': position['entry_date'],
                    'exit_date': current_date,
                    'profit': profit,
                    'return': (profit / (position['entry_price'] * position['size'])) * 100
                })
                position = None
            
            current_date += timedelta(days=1)
        
        return self.calculate_metrics(capital)
    
    def get_ai_signal(self, symbol, date):
        """Obtém sinal da IA para uma data específica"""
        response = self.client.chat.complete({
            'messages': [{
                'role': 'user',
                'content': f'Se você estivesse em {date.strftime("%Y-%m-%d")}, você compraria ou venderia {symbol}? Responda apenas BUY, SELL ou HOLD.'
            }]
        })
        return response.choices[0].message.content.strip()
    
    def calculate_metrics(self, final_capital):
        """Calcula métricas de performance"""
        initial_capital = 10000
        total_return = ((final_capital - initial_capital) / initial_capital) * 100
        
        winning_trades = [r for r in self.results if r['profit'] > 0]
        losing_trades = [r for r in self.results if r['profit'] < 0]
        
        metrics = {
            'total_return': total_return,
            'final_capital': final_capital,
            'total_trades': len(self.results),
            'winning_trades': len(winning_trades),
            'losing_trades': len(losing_trades),
            'win_rate': len(winning_trades) / len(self.results) * 100 if self.results else 0,
            'avg_win': sum(t['return'] for t in winning_trades) / len(winning_trades) if winning_trades else 0,
            'avg_loss': sum(t['return'] for t in losing_trades) / len(losing_trades) if losing_trades else 0
        }
        
        return metrics

# Executar backtest
backtest = StrategyBacktest('your_api_key')
results = backtest.test_strategy(
    'BTC',
    datetime(2024, 1, 1),
    datetime(2024, 3, 31)
)

print("📊 Resultados do Backtest:")
for key, value in results.items():
    print(f"{key}: {value}")