neural-trader

The first self-learning AI trading platform built natively for Claude Code, Cursor, GitHub Copilot, and OpenAI Codex.

Neural Trader is designed from the ground up to be built, operated, and optimized by AI coding assistants. Every command you run, every backtest you execute, and every trade you make trains the platform to get smarter—automatically learning from market patterns, optimizing strategies, and adapting to changing conditions without manual intervention.

🤖 Built for AI Coding Bots:

• 102+ MCP Tools - Native integration with Claude Desktop and AI assistants via Model Context Protocol
• Self-Learning Neural Networks - LSTM, Transformer, and N-BEATS models that improve with each execution
• Adaptive Strategy Optimization - Automatically tunes parameters based on performance feedback
• Persistent Memory - Remembers successful patterns and avoids failed approaches across sessions
• Natural Language Trading - Let AI assistants build and deploy strategies through conversation

⚡ Performance That Learns:

• 8-19x Faster than Python with Rust-powered execution
• 18 Modular Packages (3.4 KB to 5 MB) - Install only what you need
• Zero-Overhead NAPI - Native performance in JavaScript/TypeScript
• Multi-Platform - Linux, macOS, Windows with automatic platform detection

The more you use Neural Trader, the better it becomes—learning optimal entry/exit points, discovering arbitrage opportunities, and refining risk management. Perfect for developers who want AI to handle the complexity while maintaining full control.

🎯 Why Neural Trader?

🤖 AI-First Design

• Talk to Your Trading System - Build and modify strategies using natural language with Claude Code, Cursor, or Copilot
• 102+ MCP Tools - Deep integration with AI assistants via Model Context Protocol—no API wrappers, native tool access
• Self-Optimizing Strategies - Neural networks automatically tune parameters based on market feedback
• Persistent AI Memory - Remembers what works across sessions, avoiding repeated mistakes
• Zero Configuration - AI assistants handle setup, deployment, and optimization automatically

🧠 Continuous Learning

• Gets Smarter Over Time - Every backtest, trade, and market event trains the underlying neural models
• Adaptive Risk Management - VaR, CVaR, and Kelly Criterion calculations that adjust to changing volatility
• Pattern Recognition - Discovers profitable setups you didn't explicitly program
• Strategy Evolution - Automatically tests variations and adopts improvements
• Market Regime Detection - Switches strategies when market conditions change

⚡ Performance Without Compromise

• 8-19x Faster than Python—Rust-powered execution with zero-overhead JavaScript bindings
• Modular Architecture - 18 packages from 3.4 KB to 5 MB—install only what you need
• Sub-200ms Execution - Order routing, risk checks, and neural inference in real-time
• Multi-Platform - Automatic platform detection for Linux, macOS, Windows
• Production-Grade - Serving real capital in live trading environments

🚀 Complete Trading Infrastructure

• Backtesting Engine - Multi-threaded walk-forward analysis with realistic slippage
• 6+ Neural Models - LSTM, GRU, Transformer, N-BEATS, DeepAR, TCN for price prediction
• 150+ Technical Indicators - RSI, MACD, Bollinger Bands, and custom indicators
• Syndicate Management - Pool capital with Kelly Criterion allocation and governance voting
• Live Trading - Alpaca, Interactive Brokers, Binance, Coinbase integrations
• Sports Betting - Arbitrage detection, odds analysis, bankroll management

📦 Getting Started: Choose Your Installation Path

Neural Trader uses a plugin-style architecture with 18 independent packages. Think of it like LEGO blocks—start with what you need, add more as you grow.

🧭 Step 1: Decide Your Approach

❓ First time using Neural Trader or want everything instantly? → Jump to Quick Start (Complete Platform)

⚙️ Building a custom solution or optimizing bundle size? → Continue to Custom Installation Guide

🎯 Know exactly what you're building? → Skip to Use Case Templates

🌟 Quick Start (Complete Platform)

💡 Best for: First-time users, prototyping, or when you want all features immediately

Step 1: Install the complete platform

npm install neural-trader

Step 2: Try it out with AI

# Let Claude Code or Cursor build you a strategy
npx neural-trader examples

# Run the quick start guide
npx neural-trader examples --run quick-start

📊 What you get:

• ✅ All 18 packages (~5 MB total)
• ✅ Ready-to-use CLI tools
• ✅ Working examples
• ✅ Full AI assistant integration

⚠️ Note: The complete platform includes everything. If bundle size matters for your deployment, see the custom installation guide below.

⚙️ Custom Installation Guide

💡 Best for: Production deployments, serverless functions, or when every KB counts

Step 1: Start with the core (always required)

npm install @neural-trader/core

📦 Size: 3.4 KB | What it does: TypeScript types and interfaces used by all packages

Step 2: Add capabilities based on what you're building

🔍 For Backtesting:

npm install @neural-trader/backtesting @neural-trader/strategies

📦 Total: ~700 KB | What you can do: Test strategies against historical data

📈 For Live Trading:

npm install @neural-trader/strategies @neural-trader/execution \
  @neural-trader/brokers @neural-trader/risk

📦 Total: ~1.4 MB | What you can do: Execute real trades with risk management

🤖 For AI-Powered Trading:

npm install @neural-trader/neural @neural-trader/strategies \
  @neural-trader/backtesting

📦 Total: ~1.9 MB | What you can do: Use LSTM/Transformer models for predictions

🎰 For Sports Betting:

npm install @neural-trader/sports-betting @neural-trader/risk

📦 Total: ~600 KB | What you can do: Kelly Criterion betting with arbitrage detection

🧠 For AI Assistant Integration:

npm install @neural-trader/mcp
npx @neural-trader/mcp  # Starts the MCP server

📦 Total: ~200 KB | What you can do: Control trading from Claude Desktop (102+ tools)

🤝 For Syndicate Management:

npm install @neural-trader/syndicate
npx syndicate create my-fund --bankroll 100000

📦 Total: ~400 KB | What you can do: Pool capital with Kelly Criterion and voting

Step 3: Mix and match as needed

# Example: Backtesting + Neural Networks + Risk Management
npm install @neural-trader/core \
  @neural-trader/backtesting \
  @neural-trader/neural \
  @neural-trader/risk \
  @neural-trader/strategies

💡 Tip: All packages work together seamlessly. Add or remove packages anytime without breaking existing code.

🎯 Use Case Templates

Copy-paste these complete setups for common scenarios:

# Install everything needed for a production trading bot
npm install @neural-trader/core \
  @neural-trader/strategies \
  @neural-trader/backtesting \
  @neural-trader/risk \
  @neural-trader/execution \
  @neural-trader/brokers \
  @neural-trader/market-data

# Total: ~2.2 MB

# Neural networks + MCP for AI control
npm install @neural-trader/core \
  @neural-trader/neural \
  @neural-trader/strategies \
  @neural-trader/backtesting \
  @neural-trader/mcp

# Start the MCP server for Claude Desktop
npx @neural-trader/mcp

# Total: ~2.3 MB

# Minimal setup for strategy testing
npm install @neural-trader/core \
  @neural-trader/backtesting \
  @neural-trader/strategies

# Total: ~700 KB

# Sports betting with group management
npm install @neural-trader/core \
  @neural-trader/sports-betting \
  @neural-trader/syndicate \
  @neural-trader/risk

# Create a syndicate
npx syndicate create sports-fund --bankroll 50000

# Total: ~1 MB

# Polymarket, PredictIt, Augur integration
npm install @neural-trader/core \
  @neural-trader/prediction-markets \
  @neural-trader/risk

# Total: ~550 KB

💡 Pro Tip: Start with a template, test it works, then add more packages as you need them. Every package is independently versioned and tested.

📚 Available Packages

Core & Infrastructure

Trading Core (NAPI Bindings - High Performance)

Specialized Trading

Development & Tools

Meta Package

🚀 Quick Start

Complete Platform

# Install complete platform
npm install neural-trader

# Use the CLI
npx neural-trader init          # Initialize new project
npx neural-trader examples      # List available examples
npx neural-trader backtest --strategy momentum --symbol AAPL
npx neural-trader mcp          # Start MCP server for AI assistants

Modular Approach

// Install only what you need
// npm install @neural-trader/core @neural-trader/risk @neural-trader/backtesting

import { RiskManager } from '@neural-trader/risk';
import { BacktestEngine } from '@neural-trader/backtesting';
import type { RiskConfig, BacktestConfig } from '@neural-trader/core';

// 1. Set up risk management
const riskManager = new RiskManager({
  confidence_level: 0.95,
  lookback_periods: 252,
  method: 'historical'
} as RiskConfig);

// 2. Calculate risk metrics
const var95 = riskManager.calculateVar(returns, 100000);
const cvar95 = riskManager.calculateCvar(returns, 100000);
const kelly = riskManager.calculateKelly(0.6, 500, 300);

console.log(`VaR (95%): $${var95.var_amount.toFixed(2)}`);
console.log(`CVaR (95%): $${cvar95.cvar_amount.toFixed(2)}`);
console.log(`Kelly Fraction: ${(kelly.kelly_fraction * 100).toFixed(2)}%`);

// 3. Backtest strategy
const backtest = new BacktestEngine({
  initialCapital: 100000,
  startDate: '2023-01-01',
  endDate: '2023-12-31',
  commission: 0.001,
  slippage: 0.0005
} as BacktestConfig);

const results = await backtest.run(signals, 'data.csv');
console.log(`Sharpe Ratio: ${results.metrics.sharpeRatio.toFixed(2)}`);

🔧 CLI Commands

Neural Trader includes a powerful CLI for common operations:

Initialize Projects

npx neural-trader init
# Creates:
# - config.json (configuration)
# - strategies/ (custom strategies)
# - data/ (market data)
# - backtest/ (backtest results)

Run Backtests

# Simple backtest
npx neural-trader backtest --strategy momentum --symbol AAPL

# Advanced backtest with options
npx neural-trader backtest \
  --strategy pairs-trading \
  --symbols AAPL,MSFT \
  --start 2023-01-01 \
  --end 2023-12-31 \
  --initial-capital 100000 \
  --output results.json

Live Trading

# Paper trading
npx neural-trader trade --config config.json --paper

# Live trading (use with caution!)
npx neural-trader trade --config config.json --live

Analyze Results

# Analyze backtest results
npx neural-trader analyze --backtest results.json

# Generate performance report
npx neural-trader analyze --backtest results.json --report html

Examples

# List all examples
npx neural-trader examples

# Run specific example
npx neural-trader examples --run quick-start
npx neural-trader examples --run backtesting
npx neural-trader examples --run neural-models

MCP Server (AI Integration)

# Start MCP server for Claude Desktop, etc.
npx neural-trader mcp

# With custom transport
npx neural-trader mcp --transport http --port 8080

📊 Benchmarking & Optimization

Validate and optimize all packages:

# Validate all packages
npx benchoptimizer validate

# Benchmark performance
npx benchoptimizer benchmark --iterations 1000

# Get optimization suggestions
npx benchoptimizer optimize

# Generate comprehensive report
npx benchoptimizer report --format markdown --output report.md

📖 Complete API Examples

Example 1: Risk Management

import { RiskManager } from '@neural-trader/risk';
import type { RiskConfig } from '@neural-trader/core';

const riskManager = new RiskManager({
  confidence_level: 0.95,
  lookback_periods: 252,
  method: 'historical'
} as RiskConfig);

// Historical returns (daily)
const returns = [-0.02, 0.015, -0.01, 0.025, -0.005, 0.03];
const portfolioValue = 100000;

// 1. Value at Risk (VaR)
const var95 = riskManager.calculateVar(returns, portfolioValue);
console.log(`VaR (95%): $${var95.var_amount.toFixed(2)}`);
console.log(`VaR %: ${(var95.var_percentage * 100).toFixed(2)}%`);

// 2. Conditional Value at Risk (CVaR)
const cvar95 = riskManager.calculateCvar(returns, portfolioValue);
console.log(`CVaR (95%): $${cvar95.cvar_amount.toFixed(2)}`);

// 3. Kelly Criterion Position Sizing
const kelly = riskManager.calculateKelly(
  0.6,   // 60% win rate
  500,   // Average win size
  300    // Average loss size
);
console.log(`Kelly Fraction: ${(kelly.kelly_fraction * 100).toFixed(2)}%`);
console.log(`Position Size: $${kelly.position_size.toFixed(2)}`);

// 4. Drawdown Analysis
const equity = [100000, 105000, 102000, 108000, 103000, 110000];
const drawdown = riskManager.calculateDrawdown(equity);
console.log(`Max Drawdown: ${(drawdown.max_drawdown * 100).toFixed(2)}%`);
console.log(`Current Drawdown: ${(drawdown.current_drawdown * 100).toFixed(2)}%`);

Example 2: Backtesting

import { BacktestEngine } from '@neural-trader/backtesting';
import type { BacktestConfig, Signal } from '@neural-trader/core';

const engine = new BacktestEngine({
  initialCapital: 100000,
  startDate: '2023-01-01',
  endDate: '2023-12-31',
  commission: 0.001,      // 0.1% per trade
  slippage: 0.0005,       // 0.05% slippage
  useMarkToMarket: true
} as BacktestConfig);

// Generate signals (from your strategy)
const signals: Signal[] = [
  { timestamp: '2023-01-15', symbol: 'AAPL', action: 'buy', quantity: 100 },
  { timestamp: '2023-02-20', symbol: 'AAPL', action: 'sell', quantity: 100 },
  // ... more signals
];

// Run backtest
const results = await engine.run(signals, 'market-data.csv');

// Analyze results
console.log('=== Backtest Results ===');
console.log(`Total Return: ${(results.metrics.totalReturn * 100).toFixed(2)}%`);
console.log(`Sharpe Ratio: ${results.metrics.sharpeRatio.toFixed(2)}`);
console.log(`Sortino Ratio: ${results.metrics.sortinoRatio.toFixed(2)}`);
console.log(`Max Drawdown: ${(results.metrics.maxDrawdown * 100).toFixed(2)}%`);
console.log(`Win Rate: ${(results.metrics.winRate * 100).toFixed(2)}%`);
console.log(`Profit Factor: ${results.metrics.profitFactor.toFixed(2)}`);
console.log(`Total Trades: ${results.metrics.totalTrades}`);

// Compare multiple backtests
const comparison = await compareBacktests([results1, results2, results3]);
console.log('Best Sharpe Ratio:', comparison.bestSharpe.metrics.sharpeRatio);

Example 3: Neural Networks

import { NeuralModel } from '@neural-trader/neural';
import type { ModelConfig, TrainingConfig } from '@neural-trader/core';

// 1. Create LSTM model
const model = new NeuralModel({
  modelType: 'LSTM',
  inputSize: 20,          // 20 features
  horizon: 5,             // Predict 5 days ahead
  hiddenSize: 128,
  numLayers: 3,
  dropout: 0.2,
  learningRate: 0.001
} as ModelConfig);

// 2. Prepare training data
const trainingData = [...]; // Shape: [samples, sequence_length, features]
const targets = [...];      // Shape: [samples, horizon]

// 3. Train model
const trainingConfig: TrainingConfig = {
  epochs: 100,
  batchSize: 32,
  validationSplit: 0.2,
  earlyStoppingPatience: 10,
  learningRateSchedule: 'cosine',
  useGpu: true
};

const metrics = await model.train(trainingData, targets, trainingConfig);
console.log(`Final Loss: ${metrics.finalLoss.toFixed(4)}`);
console.log(`Best Validation Loss: ${metrics.bestValLoss.toFixed(4)}`);

// 4. Make predictions
const inputData = [...]; // Shape: [sequence_length, features]
const predictions = await model.predict(inputData);
console.log('Predictions:', predictions);

// 5. Save/Load model
await model.save('models/lstm_price_predictor.bin');

const loadedModel = new NeuralModel();
await loadedModel.load('models/lstm_price_predictor.bin');

Example 4: Trading Strategies

import { StrategyRunner } from '@neural-trader/strategies';
import type { StrategyConfig } from '@neural-trader/core';

const runner = new StrategyRunner();

// 1. Add momentum strategy
const momentumId = await runner.addMomentumStrategy({
  name: 'SMA Crossover',
  symbols: ['AAPL', 'MSFT', 'GOOGL'],
  parameters: JSON.stringify({
    shortPeriod: 20,
    longPeriod: 50,
    threshold: 0.02
  })
} as StrategyConfig);

// 2. Add mean reversion strategy
const meanReversionId = await runner.addMeanReversionStrategy({
  name: 'Bollinger Bands',
  symbols: ['SPY'],
  parameters: JSON.stringify({
    period: 20,
    stdDevs: 2,
    oversoldThreshold: -2,
    overboughtThreshold: 2
  })
} as StrategyConfig);

// 3. Generate signals
const signals = await runner.generateSignals();
console.log(`Generated ${signals.length} signals`);

// 4. Subscribe to real-time signals
const subscription = runner.subscribe((signal) => {
  console.log('New signal:', signal);
  // Execute trade, send notification, etc.
});

// Later: unsubscribe
subscription.unsubscribe();

Example 5: Live Trading Setup

import { BrokerClient } from '@neural-trader/brokers';
import { NeuralTrader } from '@neural-trader/execution';
import { RiskManager } from '@neural-trader/risk';
import type { BrokerConfig, OrderRequest } from '@neural-trader/core';

// 1. Connect to broker
const broker = new BrokerClient({
  brokerType: 'alpaca',
  apiKey: process.env.ALPACA_KEY,
  apiSecret: process.env.ALPACA_SECRET,
  paperTrading: true  // Start with paper trading!
} as BrokerConfig);

await broker.connect();
console.log('Connected to Alpaca (Paper Trading)');

// 2. Set up risk manager
const riskManager = new RiskManager({
  confidence_level: 0.95,
  lookback_periods: 252,
  method: 'historical'
});

// 3. Create trading system
const trader = new NeuralTrader();

// 4. Place orders with risk checks
const accountValue = 100000;
const returns = await getHistoricalReturns('AAPL');

// Check risk before trading
const var95 = riskManager.calculateVar(returns, accountValue);
const maxRisk = var95.var_amount;

console.log(`Maximum risk allowed: $${maxRisk.toFixed(2)}`);

// Place order
const order: OrderRequest = {
  symbol: 'AAPL',
  side: 'buy',
  orderType: 'market',
  quantity: 10,
  timeInForce: 'day'
};

const result = await broker.placeOrder(order);
console.log('Order placed:', result.orderId);

// 5. Monitor positions
const positions = await broker.getPositions();
positions.forEach(pos => {
  console.log(`${pos.symbol}: ${pos.quantity} shares @ $${pos.avgEntryPrice}`);
});

🏗️ Creating New Modules

Want to extend Neural Trader with your own packages? Here's how:

Step 1: Create Package Structure

mkdir -p my-neural-trader-module
cd my-neural-trader-module

# Create package.json
npm init -y

Step 2: Configure package.json

{
  "name": "@neural-trader/my-module",
  "version": "1.0.0",
  "description": "My custom Neural Trader module",
  "main": "index.js",
  "types": "index.d.ts",
  "peerDependencies": {
    "@neural-trader/core": "^1.0.0"
  },
  "publishConfig": {
    "access": "public"
  },
  "keywords": ["neural-trader", "trading", "algorithmic-trading"]
}

Step 3: Create Module Code

index.js (Option A: Pure JavaScript)

const { BaseStrategy } = require('@neural-trader/strategies');

class MyCustomStrategy extends BaseStrategy {
  constructor(config) {
    super(config);
    this.myParameter = config.myParameter || 0.5;
  }

  async generateSignals(marketData) {
    // Your custom logic here
    const signals = [];

    // Example: Simple threshold strategy
    marketData.forEach(bar => {
      if (bar.close > bar.open * (1 + this.myParameter)) {
        signals.push({
          timestamp: bar.timestamp,
          symbol: bar.symbol,
          action: 'buy',
          quantity: 100
        });
      }
    });

    return signals;
  }
}

module.exports = {
  MyCustomStrategy
};

index.js (Option B: Rust NAPI Bindings)

// If you have Rust NAPI bindings
const {
  MyCustomIndicator,
  MyCustomBacktest
} = require('./my-module.linux-x64-gnu.node');

module.exports = {
  MyCustomIndicator,
  MyCustomBacktest
};

index.d.ts (TypeScript Definitions)

import type { StrategyConfig, Signal } from '@neural-trader/core';

export class MyCustomStrategy {
  constructor(config: StrategyConfig);
  generateSignals(marketData: MarketData[]): Promise<Signal[]>;
}

export class MyCustomIndicator {
  calculate(prices: number[], period: number): number[];
}

Step 4: Add README.md

# @neural-trader/my-module

My custom Neural Trader module.

## Installation

\`\`\`bash
npm install @neural-trader/my-module
\`\`\`

## Usage

\`\`\`typescript
import { MyCustomStrategy } from '@neural-trader/my-module';

const strategy = new MyCustomStrategy({
  myParameter: 0.75
});
\`\`\`

Step 5: (Optional) Add Rust NAPI Bindings

If you want high performance, create Rust bindings:

Cargo.toml

[package]
name = "my-neural-trader-module"
version = "1.0.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
napi = "2"
napi-derive = "2"

src/lib.rs

use napi_derive::napi;

#[napi]
pub struct MyCustomIndicator {
  period: u32,
}

#[napi]
impl MyCustomIndicator {
  #[napi(constructor)]
  pub fn new(period: u32) -> Self {
    Self { period }
  }

  #[napi]
  pub fn calculate(&self, prices: Vec<f64>) -> Vec<f64> {
    // Your high-performance calculation here
    prices.iter().map(|p| p * 1.1).collect()
  }
}

Build with:

npm install -g @napi-rs/cli
napi build --platform --release

Step 6: Test Your Module

// test.ts
import { MyCustomStrategy } from './index';

const strategy = new MyCustomStrategy({
  name: 'Test',
  symbols: ['AAPL'],
  parameters: JSON.stringify({ myParameter: 0.75 })
});

const signals = await strategy.generateSignals(testData);
console.log('Generated signals:', signals);

Step 7: Publish to npm

# Test packaging
npm pack

# Publish
npm publish --access public

Module Best Practices

1. Use Core Types: Always import types from @neural-trader/core
2. Peer Dependencies: Add @neural-trader/core as peer dependency
3. Documentation: Include comprehensive README with examples
4. Testing: Add unit tests for your module
5. TypeScript: Provide .d.ts files for IntelliSense
6. Performance: Consider Rust NAPI bindings for performance-critical code
7. Versioning: Follow semver (semantic versioning)

📊 Performance Optimization

Neural Trader includes a state-of-the-art benchmarking and optimization tool:

# Install the optimizer
npm install @neural-trader/benchoptimizer

# Validate your packages
npx benchoptimizer validate --strict

# Benchmark performance
npx benchoptimizer benchmark --parallel --iterations 1000

# Get optimization suggestions
npx benchoptimizer optimize --severity high

# Generate report
npx benchoptimizer report --format html --output performance.html

What it analyzes:

• ⚡ Import/export performance
• 💾 Memory usage patterns
• 📦 Bundle size optimization
• 🔗 Dependency tree analysis
• 📊 Statistical performance metrics
• 🎯 Bottleneck detection
• ✅ Package structure validation

Performance Benchmarks (benchoptimizer itself):

• Benchmark 16 packages: ~2.3 seconds
• Validation: <500ms per package
• Memory overhead: <50MB
• Thread utilization: 95%+ on multi-core systems

🌍 Multi-Platform Support

Neural Trader supports 5 platforms out of the box:

Platform-specific bindings are automatically downloaded during installation.

📊 Performance Benchmarks

Neural Trader's Rust core provides exceptional performance:

Benchmarks run on AMD Ryzen 9 5950X, 32GB RAM, Ubuntu 22.04

🔌 Integration Examples

Claude Desktop MCP Integration

// claude_desktop_config.json
{
  "mcpServers": {
    "neural-trader": {
      "command": "npx",
      "args": ["neural-trader", "mcp"]
    }
  }
}

Now you can ask Claude: "Backtest a momentum strategy on AAPL for 2023"

Custom Webhook Integration

import { StrategyRunner } from '@neural-trader/strategies';
import express from 'express';

const app = express();
const runner = new StrategyRunner();

app.post('/webhook/tradingview', async (req, res) => {
  const alert = req.body;

  // Execute trade based on TradingView alert
  if (alert.action === 'buy') {
    await executeTrade(alert.symbol, 'buy', alert.quantity);
  }

  res.json({ success: true });
});

app.listen(3000);

Telegram Bot Integration

import { Telegraf } from 'telegraf';
import { RiskManager } from '@neural-trader/risk';

const bot = new Telegraf(process.env.TELEGRAM_TOKEN);
const riskManager = new RiskManager({ confidence_level: 0.95 });

bot.command('risk', async (ctx) => {
  const var95 = riskManager.calculateVar(recentReturns, portfolioValue);
  ctx.reply(`Current VaR (95%): $${var95.var_amount.toFixed(2)}`);
});

bot.launch();

🛠️ Development

Building from Source

git clone https://github.com/ruvnet/neural-trader.git
cd neural-trader/neural-trader-rust

# Install dependencies
npm install

# Build Rust bindings
npm run build

# Run tests
npm test

# Build all packages
npm run build:all

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

📚 Additional Resources

Documentation

• Complete Documentation
• API Reference
• Architecture Guide
• Migration Guide

Examples

• Quick Start Example
• Backtesting Example
• Live Trading Example
• Neural Models Example

Community

• GitHub Discussions
• Issue Tracker
• Discord Server (coming soon)

⚖️ License

This package is dual-licensed under MIT OR Apache-2.0.

• MIT License: https://opensource.org/licenses/MIT
• Apache-2.0 License: https://www.apache.org/licenses/LICENSE-2.0

You may choose either license for your use.

⚠️ Disclaimer

Trading involves substantial risk and is not suitable for every investor. Past performance is not indicative of future results. Neural Trader is provided as-is without warranties. Use at your own risk. Always test strategies thoroughly in paper trading before live deployment.

🙏 Acknowledgments

Built with:

• Rust 🦀 - High-performance core
• NAPI-RS - Native Node.js bindings
• TypeScript - Type-safe JavaScript
• Claude Code - AI-assisted development

Built with Rust 🦀 | Powered by Neural Networks 🧠 | Ready for Production ✨

Questions? Open an issue or start a discussion on GitHub!