162 lines
4.7 KiB
Markdown
162 lines
4.7 KiB
Markdown
# Trading Agent System
|
|
|
|
This directory contains the implementation of a modular trading agent system that integrates with the neural network models and can execute trades on various cryptocurrency exchanges.
|
|
|
|
## Overview
|
|
|
|
The trading agent system is designed to:
|
|
|
|
1. Connect to different cryptocurrency exchanges using a common interface
|
|
2. Execute trades based on signals from neural network models
|
|
3. Manage risk through position sizing, trade limits, and cooldown periods
|
|
4. Monitor and report on trading activity
|
|
|
|
## Components
|
|
|
|
### Exchange Interfaces
|
|
|
|
- `ExchangeInterface`: Abstract base class defining the common interface for all exchange implementations
|
|
- `BinanceInterface`: Implementation for the Binance exchange, with support for both mainnet and testnet
|
|
- `MEXCInterface`: Implementation for the MEXC exchange
|
|
|
|
### Trading Agent
|
|
|
|
The `TradingAgent` class (`trading_agent.py`) manages trading activities:
|
|
|
|
- Connects to the configured exchange
|
|
- Processes trading signals from neural network models
|
|
- Applies trading rules and risk management
|
|
- Tracks and reports trading performance
|
|
|
|
### Neural Network Orchestrator
|
|
|
|
The `NeuralNetworkOrchestrator` class (`neural_network_orchestrator.py`) coordinates between models and trading:
|
|
|
|
- Manages the neural network inference process
|
|
- Routes model signals to the trading agent
|
|
- Provides integration with the RealTimeChart for visualization
|
|
|
|
## Usage
|
|
|
|
### Basic Usage
|
|
|
|
```python
|
|
from NN.exchanges import BinanceInterface, MEXCInterface
|
|
from NN.trading_agent import TradingAgent
|
|
|
|
# Initialize an exchange interface
|
|
exchange = BinanceInterface(
|
|
api_key="your_api_key",
|
|
api_secret="your_api_secret",
|
|
test_mode=True # Use testnet
|
|
)
|
|
|
|
# Connect to the exchange
|
|
exchange.connect()
|
|
|
|
# Create a trading agent
|
|
agent = TradingAgent(
|
|
exchange_name="binance",
|
|
api_key="your_api_key",
|
|
api_secret="your_api_secret",
|
|
test_mode=True,
|
|
trade_symbols=["BTC/USDT", "ETH/USDT"],
|
|
position_size=0.1,
|
|
max_trades_per_day=5,
|
|
trade_cooldown_minutes=60
|
|
)
|
|
|
|
# Start the trading agent
|
|
agent.start()
|
|
|
|
# Process a trading signal
|
|
agent.process_signal(
|
|
symbol="BTC/USDT",
|
|
action="BUY",
|
|
confidence=0.85,
|
|
timestamp=int(time.time())
|
|
)
|
|
|
|
# Stop the trading agent when done
|
|
agent.stop()
|
|
```
|
|
|
|
### Integration with Neural Network Models
|
|
|
|
The system is designed to be integrated with neural network models through the `NeuralNetworkOrchestrator`:
|
|
|
|
```python
|
|
from NN.neural_network_orchestrator import NeuralNetworkOrchestrator
|
|
|
|
# Configure exchange
|
|
exchange_config = {
|
|
"exchange": "binance",
|
|
"api_key": "your_api_key",
|
|
"api_secret": "your_api_secret",
|
|
"test_mode": True,
|
|
"trade_symbols": ["BTC/USDT", "ETH/USDT"],
|
|
"position_size": 0.1,
|
|
"max_trades_per_day": 5,
|
|
"trade_cooldown_minutes": 60
|
|
}
|
|
|
|
# Initialize orchestrator
|
|
orchestrator = NeuralNetworkOrchestrator(
|
|
model=model,
|
|
data_interface=data_interface,
|
|
chart=chart,
|
|
symbols=["BTC/USDT", "ETH/USDT"],
|
|
timeframes=["1m", "5m", "1h", "4h", "1d"],
|
|
exchange_config=exchange_config
|
|
)
|
|
|
|
# Start inference and trading
|
|
orchestrator.start_inference()
|
|
```
|
|
|
|
## Configuration
|
|
|
|
### Exchange-Specific Configuration
|
|
|
|
- **Binance**: Supports both mainnet and testnet environments
|
|
- **MEXC**: Supports mainnet only (no test environment available)
|
|
|
|
### Trading Agent Configuration
|
|
|
|
- `exchange_name`: Name of exchange ('binance', 'mexc')
|
|
- `api_key`: API key for the exchange
|
|
- `api_secret`: API secret for the exchange
|
|
- `test_mode`: Whether to use test/sandbox environment
|
|
- `trade_symbols`: List of trading symbols to monitor
|
|
- `position_size`: Size of each position as a fraction of balance (0.0-1.0)
|
|
- `max_trades_per_day`: Maximum number of trades to execute per day
|
|
- `trade_cooldown_minutes`: Minimum time between trades in minutes
|
|
|
|
## Adding New Exchanges
|
|
|
|
To add support for a new exchange:
|
|
|
|
1. Create a new class that inherits from `ExchangeInterface`
|
|
2. Implement all required methods (see `exchange_interface.py`)
|
|
3. Add the new exchange to the imports in `__init__.py`
|
|
4. Update the `_create_exchange` method in `TradingAgent` to support the new exchange
|
|
|
|
Example:
|
|
|
|
```python
|
|
class KrakenInterface(ExchangeInterface):
|
|
"""Kraken Exchange API Interface"""
|
|
|
|
def __init__(self, api_key=None, api_secret=None, test_mode=True):
|
|
super().__init__(api_key, api_secret, test_mode)
|
|
# Initialize Kraken-specific attributes
|
|
|
|
# Implement all required methods...
|
|
```
|
|
|
|
## Security Considerations
|
|
|
|
- API keys should have trade permissions but not withdrawal permissions
|
|
- Use environment variables or secure storage for API credentials
|
|
- Always test with small position sizes before deploying with larger amounts
|
|
- Consider using test mode/testnet for initial testing |