Upload folder using huggingface_hub

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - huggingface-deployment
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gitignore

@@ -0,0 +1,94 @@
+# Virtual Environment
+venv/
+env/
+ENV/
+
+# Python bytecode
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+*.egg
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+# Allow .env.example
+!.env.example
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IDE files
+.idea/
+.vscode/
+*.swp
+*.swo
+.cursor/
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Result files and data
+results/*.json
+results/*.txt
+db/*.db
+*.sqlite
+*.sqlite3
+
+# Log files
+logs/
+*.log
+
+# Other
+.DS_Store
+Thumbs.db
+node_modules/
+
+# Project specific
+requirements_installed
+*__pycache__/
+**/__pycache__/
+**/._*
+
+# Large files
+*.pkl
+*.parquet
+*.model
+*.bin
+*.h5
+*.hdf5
+*.pickle
+*.joblib
+*.tar.gz
+*.zip
+*.rar
+*.7z
+
+# Database files (extended)
+db/chroma.sqlite3
+db/chroma/*
+**/*.db-shm
+**/*.db-wal
+
+# Cache directories
+**/.cache/
+**/cache/
+**/__pycache__/ 

AUTO_TRADING_GUIDE.md

@@ -0,0 +1,154 @@
+# Automated Trading Guide for CrypticAI
+
+This guide provides detailed instructions for setting up and running the CrypticAI trading system for extended periods of time (days or weeks).
+
+## Getting Started
+
+### Prerequisites
+
+- Python 3.9 or higher
+- All dependencies installed (see `requirements.txt`)
+- Alpaca API keys properly configured in your `.env` file
+- Enough trading capital in your Alpaca account
+
+### Basic Setup
+
+1. Configure your API keys in `.env` file:
+   ```
+   ALPACA_API_KEY=your_api_key_here
+   ALPACA_API_SECRET=your_api_secret_here
+   OPENAI_API_KEY=your_openai_api_key_here
+   ```
+
+2. Make the restart script executable:
+   ```bash
+   chmod +x run_trader.sh
+   ```
+
+## Running Automated Trading
+
+### Option 1: Using the Web Interface
+
+1. Start the application:
+   ```bash
+   python src/ui/app.py
+   ```
+
+2. Open the web interface at http://localhost:7860
+
+3. Navigate to the "Strategy Configuration" tab and either:
+   - Load an existing strategy
+   - Create a new strategy
+
+4. Set your desired timeframe (how often analysis runs) and maximum allocation percentage
+
+5. Go to the "Automated Analysis" tab and click "Start Automated Analysis"
+
+6. The system will now run continuously until stopped, executing trades based on your strategy
+
+### Option 2: Using the Monitor Script (Recommended for Long-Term)
+
+For running the system for days or weeks, use the restart script:
+
+```bash
+./run_trader.sh
+```
+
+This script will:
+- Start the CrypticAI application
+- Automatically restart it if it crashes
+- Log all restarts to `trader_monitor.log`
+
+### Using Screen or Tmux for Remote Servers
+
+If running on a remote server, use `screen` or `tmux` to keep the session alive:
+
+```bash
+# Start a new screen session
+screen -S cryptic_trading
+
+# Then run the monitor script
+./run_trader.sh
+
+# Detach from the session with Ctrl+A, D
+# You can now safely close your SSH connection
+
+# To reconnect later:
+screen -r cryptic_trading
+```
+
+## Monitoring Your Trades
+
+### Logs
+
+The system creates detailed logs of all trading activity:
+
+1. **Trading Session Logs**: Located in `data/` directory with names like `auto_trading_log_20250401_123045.txt`
+   - Contains all analysis results, trades, positions, and account balances
+   - A new log file is created each time the automated analysis is started
+
+2. **Monitor Logs**: If using the restart script, check `trader_monitor.log` for application crashes and restarts
+
+### Web Interface
+
+While the system is running, you can monitor activity through the web interface:
+
+1. "Monitoring" tab:
+   - Shows recent analysis results
+   - Current positions
+   - Transaction history
+
+2. "Trading" tab:
+   - Displays account summary
+   - Current active positions
+
+## Analyzing Trading Performance
+
+After running the system for a period, analyze performance:
+
+1. Review the trading logs in `data/` directory
+2. Check account performance in "Trading" tab
+3. Review all transactions in "Monitoring" tab
+
+## Stopping the System
+
+To stop automated trading:
+
+1. From the web interface:
+   - Go to "Automated Analysis" tab
+   - Click "Stop Automated Analysis"
+
+2. If using the monitor script:
+   - Press Ctrl+C to terminate the script
+   - Or kill the screen session with `screen -X -S cryptic_trading quit`
+
+## Troubleshooting
+
+### Common Issues
+
+1. **API Rate Limits**: If you encounter rate limit errors, consider increasing the timeframe interval
+
+2. **Application Crashes**: Check `trader_monitor.log` for error details if using the restart script
+
+3. **Connection Issues**: If remote connection drops, the script will continue running in screen/tmux
+
+### Emergency Stop
+
+If you need to quickly stop all trading activity:
+
+1. Go to the "Trading" tab
+2. Click "Reset Portfolio" to close all positions
+
+## Best Practices
+
+1. **Start Small**: Begin with small allocation percentages to test your strategy
+
+2. **Monitor Regularly**: Check on the system daily to ensure it's functioning correctly
+
+3. **Backup Logs**: Periodically backup your logs for analysis
+
+4. **Update Strategies**: Refine your strategy based on performance data from logs
+
+5. **Server Uptime**: If running on your own server, ensure it has reliable power and internet connectivity
+
+Happy automated trading with CrypticAI! 

README.md

@@ -1,12 +1,215 @@
 ---
-title: Cryptic
-emoji: 👁
-colorFrom: red
-colorTo: green
+title: cryptic
+app_file: src/ui/app.py
 sdk: gradio
-sdk_version: 5.23.3
-app_file: app.py
-pinned: false
+sdk_version: 5.23.1
 ---
+# CrypticAI - Bitcoin Sentiment Analysis
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+An AI agentic workflow for Bitcoin price sentiment analysis that combines technical analysis strategies, news sentiment, and market context to provide trading recommendations with confidence scores.
+
+## Overview
+
+CrypticAI uses a four-stage agentic workflow to analyze Bitcoin's market conditions:
+
+1. **Technical Strategy Agent** - Implements a 5-minute timeframe RSI + Bollinger Bands trading strategy to generate precise buy/sell signals
+2. **Initial Analysis Agent** - Examines the technical strategy signal alongside broader market indicators, news sentiment, and cryptocurrency market context
+3. **Reflection Agent** - Critically evaluates both the technical strategy and initial analysis to identify potential blind spots
+4. **Final Synthesis Agent** - Produces a final recommendation with confidence score and portfolio allocation percentage, and executes trades via Alpaca
+
+## Features
+
+- Technical trading strategy using RSI and Bollinger Bands indicators
+- Broader technical analysis using RSI, ADX, and Bollinger Bands across multiple timeframes
+- News and social media sentiment analysis of Bitcoin and crypto markets
+- Comprehensive cryptocurrency market context analysis including:
+  - BTC dominance metrics
+  - Market-wide trends across top cryptocurrencies
+  - Comparative performance data between Bitcoin and other major coins
+- Multiple data sources including Alpaca and Yahoo Finance APIs
+- Structured trading recommendations with confidence scores and portfolio allocation percentages
+- Automatic trade execution through the Alpaca Crypto API
+- Option to run in monitoring mode for continuous analysis
+- Interactive Gradio UI for strategy tuning and order monitoring
+- **Enhanced error handling with exponential backoff retry mechanism**
+- **Data validation and graceful degradation when data sources are unavailable**
+- **Comprehensive logging for improved traceability**
+- **Intelligent caching system to reduce API calls and handle temporary outages**
+
+## Setup
+
+### Prerequisites
+
+- Python 3.10 or higher
+- API keys for:
+  - Alpaca (for Bitcoin price data and trade execution)
+  - OpenAI (for the LLM agents)
+
+### Installation
+
+1. Clone the repository:
+   ```
+   git clone https://github.com/yourusername/crypticai.git
+   cd crypticai
+   ```
+
+2. Create and activate a virtual environment:
+   ```
+   python -m venv venv
+   source venv/bin/activate  # On Windows, use: venv\Scripts\activate
+   ```
+
+3. Install dependencies:
+   ```
+   pip install -r requirements.txt
+   ```
+
+4. Create a `.env` file with your API keys:
+   ```
+   ALPACA_API_KEY=your_alpaca_api_key
+   ALPACA_API_SECRET=your_alpaca_api_secret
+   NEWS_API_KEY=your_newsapi_key
+   OPENAI_API_KEY=your_openai_api_key
+   ```
+
+## Usage
+
+### Single Analysis
+
+To run a one-time analysis:
+
+```
+python main.py
+```
+
+### Monitoring Mode
+
+To run in monitoring mode (analysis every 4 hours):
+
+```
+python -m src.crypto_analysis.main monitor
+```
+
+Press `Ctrl+C` to exit monitoring mode.
+
+### Trading Dashboard UI
+
+To launch the interactive trading dashboard UI:
+
+```
+python run_ui.py
+```
+
+The UI provides:
+
+1. **Strategy Configuration** - Adjust RSI thresholds and Bollinger Bands parameters
+2. **Trading** - Execute manual trades and view account information
+3. **Monitoring** - Track active positions and order history
+4. **Automated Analysis** - Run the strategy in the background (every 5 minutes)
+
+### Training Mode
+
+To train the crew (experimental feature for improved performance):
+
+```
+python -m src.crypto_analysis.main train 5  # Run 5 training iterations
+```
+
+## Output
+
+The analysis produces a trading recommendation with:
+
+- **Signal**: BUY, SELL, or HOLD
+- **Confidence**: Confidence score as percentage (0-100%)
+- **Allocation**: Suggested portfolio allocation percentage
+- **Reasoning**: Concise explanation for the recommendation
+- **Tool Error Assessment**: Information about any data retrieval issues
+- **Data Reliability**: Assessment of the reliability of the data used
+
+Results are displayed in the console and saved as JSON files in the `results` directory. Detailed logs are also saved to the `logs` directory.
+
+## Technical Strategies
+
+### 5-Minute RSI + Bollinger Bands Strategy
+
+The technical analysis agent implements a structured 5-minute timeframe strategy:
+
+#### Buy Signal (Long)
+1. RSI falls below 40 (mildly oversold condition)
+2. Price touches or approaches the lower Bollinger Band
+3. Optimal entry when price starts bouncing up from the lower band
+
+#### Sell Signal (Short)
+1. RSI rises above 60 (mildly overbought condition)
+2. Price touches or approaches the upper Bollinger Band
+3. Optimal entry when price starts reversing down from the upper band
+
+### Broader Technical Analysis
+
+The system also evaluates:
+
+1. Market ranging/trending conditions using ADX
+2. RSI values across multiple timeframes
+3. Price positions relative to Bollinger Bands
+4. Support/resistance levels and trend lines
+
+### Market Context Analysis
+
+The YahooCryptoMarketTool enhances analysis by providing:
+
+1. Market-wide cryptocurrency trends (bullish/bearish)
+2. Bitcoin dominance percentage of total market cap
+3. Comparative performance data for top 10 cryptocurrencies
+4. Day-over-day and week-over-week price changes across the market
+
+## Data Tools
+
+The system leverages several specialized data tools:
+
+1. **YahooBitcoinDataTool** - Fetches Bitcoin price data from Yahoo Finance
+2. **YahooCryptoMarketTool** - Provides broader cryptocurrency market context
+3. **RealBitcoinNewsTool** - Gathers latest Bitcoin news and sentiment
+4. **TechnicalAnalysisStrategy** - Applies technical indicators to generate signals
+5. **AlpacaCryptoOrderTool** - Executes trade orders based on final recommendations
+
+## Reliability Features
+
+### Error Handling and Retry Logic
+
+All API calls include robust error handling with configurable retry mechanisms:
+
+1. **Exponential Backoff** - Automatic retry with increasing wait times between attempts
+2. **Alternative Data Sources** - Fallback to alternative ticker symbols when primary ones fail
+3. **Data Validation** - Verification of data completeness and format before proceeding
+4. **Graceful Degradation** - The system continues to function with reduced confidence when some data sources are unavailable
+
+### Caching System
+
+An intelligent caching system reduces API calls and improves reliability:
+
+1. **Time-Based Caching** - Results are cached for configurable time periods
+2. **Cache Validation** - Automatic detection of when cached data is stale
+3. **Memory-Efficient Storage** - Optimized storage of cached data to prevent memory issues
+
+### Comprehensive Logging
+
+Enhanced logging provides traceability and debugging capabilities:
+
+1. **Structured Logs** - All system activities are logged with timestamps and contextual information
+2. **Log Rotation** - Daily log files to prevent excessive file sizes
+3. **Error Tracebacks** - Full error traces captured for debugging
+4. **Status Monitoring** - Tool state tracking throughout the analysis process
+
+## Extending the System
+
+The system is designed to be modular and extensible:
+
+1. Add new tools in the `src/crypto_analysis/tools` directory
+2. Modify agent configurations in `src/crypto_analysis/config/agents.yaml`
+3. Adjust task descriptions in `src/crypto_analysis/config/tasks.yaml`
+4. Add new technical strategies in `src/crypto_analysis/tools/technical_tools.py`
+5. Customize error handling in the `src/crypto_analysis/utils/api_helpers.py` file
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

data/auto_trading_log_20250401_104519.txt

@@ -0,0 +1,13 @@
+Automated trading session started at 2025-04-01T10:45:19.642169
+Strategy parameters: {"timeframe_minutes": 60, "max_allocation_percentage": 5, "strategy_text": "Buy when RSI is below 20 and the price is near the lower Bollinger Band (position < 0.2).\nSell when RSI is above 90 and the price is near the upper Bollinger Band (position > 0.8).\nIncrease confidence if the ADX shows a strong trend (> 25) in the same direction.\nUse 40% of available capital for trades if confidence is high (> 70), otherwise use 20%."}
+
+
+--- Analysis run at 2025-04-01T10:45:19.642900 ---
+Signal: hold, Confidence: 50%, Allocation: 0%
+Reasoning: A hold position is prudent given stable technical signals, bullish broader market, and optimistic sentiment. No immediate allocation change is warranted. Monitoring for developments is advised.
+Order info: Account check completed
+
+Current Positions:
+  BTCUSD: 0.326226192 @ $85148.722929033 - P/L: $-678.92 (-2.44%)
+
+Account Balance: $63823.62, Equity: $97356.49

data/auto_trading_log_20250401_112240.txt

@@ -0,0 +1,24 @@
+Automated trading session started at 2025-04-01T11:22:40.319064
+Strategy parameters: {"timeframe_minutes": 60, "max_allocation_percentage": 5, "strategy_text": "Buy when RSI is below 20 and the price is near the lower Bollinger Band (position < 0.2).\nSell when RSI is above 90 and the price is near the upper Bollinger Band (position > 0.8).\nIncrease confidence if the ADX shows a strong trend (> 25) in the same direction.\nUse 40% of available capital for trades if confidence is high (> 70), otherwise use 20%."}
+
+
+--- Analysis run at 2025-04-01T11:22:40.319524 ---
+Signal: buy, Confidence: 30%, Allocation: 5%
+Reasoning: ** 
+  - The technical indicators are neutral, with low confidence levels, leading to a hold recommendation. The broader market context is bullish, but Bitcoin's recent bearish trend and mixed sentiment suggest caution. No clear buy or sell signals warrant a change in the current position, thus recommending to hold with no allocation.
+Order info: Account check completed
+
+Current Positions:
+  BTCUSD: 0.326226192 @ $85148.722929033 - P/L: $-598.67 (-2.16%)
+
+Account Balance: $63823.62, Equity: $97436.75
+
+--- Analysis run at 2025-04-01T12:24:04.632925 ---
+Signal: sell, Confidence: 60%, Allocation: 20%
+Reasoning: The technical indicators, particularly the Bollinger Bands, indicate a sell condition with moderate confidence supported by the ADX. However, the broader market's bullish trend and positive sentiment suggest caution. I have adjusted the confidence level to 60% to reflect these mixed signals. Given the allocation recommendation of 20%, this trade remains within the user's maximum limit.
+Order info: manually based on this recommendation and detailed analysis.
+
+Current Positions:
+  BTCUSD: 0.260980952 @ $85148.722929033 - P/L: $-481.7 (-2.17%)
+
+Account Balance: $69254.43, Equity: $97428.98

main.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""
+Bitcoin Analysis Project - Main Script
+
+This script runs the Bitcoin analysis crew to generate investment recommendations
+integrating technical analysis, news sentiment, and market context.
+"""
+
+import os
+import json
+import time
+from datetime import datetime
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Check for required API keys
+if not os.getenv("OPENAI_API_KEY"):
+    print("Error: OPENAI_API_KEY not found in environment variables")
+    print("Please set up your .env file with the required API keys")
+    exit(1)
+
+if not os.getenv("ALPACA_API_KEY") or not os.getenv("ALPACA_API_SECRET"):
+    print("Error: ALPACA_API_KEY or ALPACA_API_SECRET not found in environment variables")
+    print("Please set up your .env file with the required Alpaca API keys")
+    exit(1)
+
+# Import the BitcoinAnalysisCrew
+from src.crypto_analysis.crew import BitcoinAnalysisCrew
+
+def main():
+    """Run the Bitcoin analysis project"""
+    print("=" * 80)
+    print("BITCOIN ANALYSIS PROJECT")
+    print("=" * 80)
+    print(f"Run started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("Initializing Bitcoin Analysis Crew...")
+    
+    # Create the crew
+    try:
+        crew = BitcoinAnalysisCrew()
+        print("Crew initialized successfully")
+        print("Starting Bitcoin analysis...")
+        
+        # Run the analysis
+        result = crew.run_analysis()
+        
+        # Print the results
+        print("\n" + "=" * 40)
+        print("ANALYSIS RESULTS")
+        print("=" * 40)
+        print(f"Signal: {result.get('signal', 'unknown').upper()}")
+        print(f"Confidence: {result.get('confidence', 0)}%")
+        print(f"Allocation: {result.get('allocation_percentage', 0)}%")
+        if 'reasoning' in result:
+            print("\nReasoning:")
+            print(result['reasoning'])
+        
+        # Save the results to a file
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        results_dir = "results"
+        os.makedirs(results_dir, exist_ok=True)
+        
+        results_file = os.path.join(results_dir, f"bitcoin_analysis_{timestamp}.json")
+        with open(results_file, "w") as f:
+            json.dump(result, f, indent=2)
+        
+        print(f"\nResults saved to {results_file}")
+        print("=" * 80)
+        
+        # Check if order execution happened
+        if 'order_execution' in result:
+            print("\nORDER EXECUTION RESULTS:")
+            print("-" * 40)
+            order_result = result['order_execution']
+            if isinstance(order_result, dict):
+                if order_result.get('success', False):
+                    print(f"Order {order_result.get('order_id', 'unknown')} executed successfully!")
+                    print(f"Side: {order_result.get('side', 'unknown').upper()}")
+                    print(f"Symbol: {order_result.get('symbol', 'unknown')}")
+                    print(f"Quantity: {order_result.get('quantity', 'unknown')}")
+                    print(f"Status: {order_result.get('status', 'unknown')}")
+                    print(f"Current price: ${order_result.get('current_price', 'unknown')}")
+                else:
+                    print(f"Order execution failed: {order_result.get('error', 'Unknown error')}")
+            else:
+                print(f"Account check completed: {order_result}")
+        
+        return 0
+        
+    except Exception as e:
+        print(f"Error in analysis: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return 1
+
+if __name__ == "__main__":
+    main() 

requirements.txt

@@ -0,0 +1,54 @@
+# Core packages
+python-dotenv==1.1.0
+crewai==0.108.0
+openai==1.68.2
+langchain==0.3.21
+langchain-openai==0.2.14
+pydantic==2.10.6
+pydantic-settings==2.8.1
+
+# Database and storage
+chromadb==0.5.23
+sqlalchemy==2.0.39
+peewee==3.17.9
+
+# Data analysis
+pandas==2.2.3
+numpy==2.2.4
+pandas-ta==0.3.14b0
+
+# Financial APIs
+alpaca-py==0.39.1
+yfinance==0.2.55
+newsapi-python==0.2.7
+
+# Data visualization
+matplotlib==3.10.1
+
+# HTTP and utilities
+requests==2.32.3
+aiohttp==3.11.14
+httpx==0.27.2
+tenacity==8.5.0
+backoff==2.2.1
+
+# Web scraping and text processing
+beautifulsoup4==4.13.3
+pysbd==0.3.4
+regex==2024.11.6
+
+# UI dependencies
+gradio==5.23.1
+fastapi==0.115.12
+uvicorn==0.34.0
+
+# Date and time utilities
+python-dateutil==2.9.0.post0
+pytz==2024.2
+
+# Logging and error tracking
+structlog==24.1.0
+pythonjsonlogger==2.0.7
+
+# Testing dependencies
+pytest>=7.0.0

results/report_20250328_160002.md

@@ -0,0 +1,33 @@
+
+# BITCOIN TRADING RECOMMENDATION REPORT
+## March 28, 2025 16:00
+
+## EXECUTIVE SUMMARY
+### ⚪ HOLD with 0% confidence
+### Allocation: 0% of portfolio
+
+## TECHNICAL ANALYSIS
+No technical analysis available
+
+## MARKET CONTEXT
+No market context available
+
+## SENTIMENT ANALYSIS
+No sentiment analysis available
+
+## DECISION FACTORS
+- Technical Factors: No impact data available
+- Market Context: No impact data available
+- Sentiment: No impact data available
+
+## MARKET OUTLOOK
+No market outlook available
+
+## RISK ASSESSMENT
+No risk assessment available
+
+## DETAILED REASONING
+Error parsing result: local variable 're' referenced before assignment
+
+## ORDER EXECUTION
+No order execution details available

run.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+# Activate virtual environment
+if [ -d "venv" ]; then
+    source venv/bin/activate
+    echo "Virtual environment activated"
+else
+    echo "Virtual environment not found. Creating one..."
+    python -m venv venv
+    source venv/bin/activate
+    pip install poetry
+    poetry install
+    echo "Virtual environment created and activated"
+fi
+
+# Check if .env file exists
+if [ ! -f ".env" ]; then
+    echo "Error: .env file not found."
+    echo "Please create a .env file with your API keys based on .env.example"
+    exit 1
+fi
+
+# Parse command line arguments
+if [ "$1" == "monitor" ]; then
+    echo "Starting Bitcoin analysis in monitoring mode..."
+    python -m src.crypto_analysis.main monitor
+elif [ "$1" == "train" ]; then
+    ITERATIONS=${2:-1}
+    echo "Training Bitcoin analysis crew for $ITERATIONS iterations..."
+    python -m src.crypto_analysis.main train $ITERATIONS
+else
+    echo "Running one-time Bitcoin analysis..."
+    python -m src.crypto_analysis.main
+fi 

run_trader.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+
+# Configuration
+MAX_RESTARTS=10
+RESTART_DELAY=60  # seconds
+LOG_FILE="trader_monitor.log"
+APP_PATH="src/ui/app.py"
+
+echo "Starting CrypticAI Trading Monitor at $(date)" | tee -a "$LOG_FILE"
+echo "This script will automatically restart the application if it crashes" | tee -a "$LOG_FILE"
+echo "Press CTRL+C to stop the monitor" | tee -a "$LOG_FILE"
+echo "---------------------------------------------------------" | tee -a "$LOG_FILE"
+
+restart_count=0
+
+while [ $restart_count -lt $MAX_RESTARTS ]; do
+    echo "Starting CrypticAI Trading application (attempt $((restart_count+1)))" | tee -a "$LOG_FILE"
+    echo "$(date): Starting application" | tee -a "$LOG_FILE"
+    
+    # Run the application
+    python "$APP_PATH"
+    
+    # Check exit status
+    exit_status=$?
+    
+    if [ $exit_status -eq 0 ]; then
+        echo "$(date): Application exited normally with status $exit_status" | tee -a "$LOG_FILE"
+        echo "Exiting monitor as requested" | tee -a "$LOG_FILE"
+        break
+    else
+        restart_count=$((restart_count+1))
+        echo "$(date): Application crashed with status $exit_status" | tee -a "$LOG_FILE"
+        
+        if [ $restart_count -lt $MAX_RESTARTS ]; then
+            echo "Restarting in $RESTART_DELAY seconds... ($restart_count of $MAX_RESTARTS)" | tee -a "$LOG_FILE"
+            sleep $RESTART_DELAY
+        else
+            echo "Maximum restart attempts ($MAX_RESTARTS) reached. Giving up." | tee -a "$LOG_FILE"
+        fi
+    fi
+done
+
+echo "$(date): Monitor script terminated" | tee -a "$LOG_FILE" 

run_ui.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""
+CrypticAI - Bitcoin Trading Dashboard
+
+Run this script to start the Gradio UI for the CrypticAI Bitcoin Trading Dashboard.
+"""
+
+import os
+import sys
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Check for required API keys
+if not os.getenv("OPENAI_API_KEY"):
+    print("Error: OPENAI_API_KEY not found in environment variables")
+    print("Please set up your .env file with the required API keys")
+    sys.exit(1)
+
+if not os.getenv("ALPACA_API_KEY") or not os.getenv("ALPACA_API_SECRET"):
+    print("Error: ALPACA_API_KEY or ALPACA_API_SECRET not found in environment variables")
+    print("Please set up your .env file with the required Alpaca API keys")
+    sys.exit(1)
+
+# Import and run the Gradio app
+from src.ui.app import app
+
+if __name__ == "__main__":
+    print("=" * 80)
+    print("CrypticAI - Bitcoin Trading Dashboard")
+    print("=" * 80)
+    print("Starting Gradio UI...")
+    
+    # Ensure results directory exists
+    os.makedirs("results", exist_ok=True)
+    
+    # Launch the app
+    app.launch(share=False) 

run_ui.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# Script to run the CrypticAI Trading Dashboard UI
+
+# Ensure virtual environment is activated if it exists
+if [ -d "venv" ]; then
+    echo "Activating virtual environment..."
+    source venv/bin/activate
+fi
+
+# Check if python is available
+if ! command -v python &> /dev/null; then
+    echo "Python not found. Please install Python 3.10 or higher."
+    exit 1
+fi
+
+# Check if dependencies are installed
+if [ ! -f "requirements_installed" ]; then
+    echo "Installing dependencies..."
+    pip install -r requirements.txt
+    touch requirements_installed
+fi
+
+# Run the UI
+echo "Starting CrypticAI Trading Dashboard..."
+python run_ui.py 

setup.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+echo "Setting up Bitcoin Technical Analysis environment..."
+
+# Ensure virtual environment is active
+if [[ "$VIRTUAL_ENV" == "" ]]; then
+    echo "Virtual environment not active. Please activate it first with:"
+    echo "source venv/bin/activate"
+    exit 1
+fi
+
+# Install dependencies with fixed versions
+echo "Installing dependencies with fixed versions..."
+pip install -r requirements.txt
+
+# Check if numpy has NaN attribute
+echo "Checking numpy configuration..."
+python -c "
+import numpy as np
+try:
+    # Try to access np.NaN
+    print(f'numpy.NaN exists: {np.NaN is np.nan}')
+except AttributeError:
+    # If it doesn't exist, add it
+    print('Adding NaN to numpy...')
+    np.NaN = np.nan
+"
+
+echo "Setup complete. Running Bitcoin analysis..."
+python main.py 

src/__init__.py

@@ -0,0 +1,3 @@
+"""
+CrypticAI package for Bitcoin price sentiment analysis
+""" 

src/crypto_analysis/__init__.py

@@ -0,0 +1,5 @@
+"""
+Bitcoin price sentiment analysis with agentic workflow
+"""
+
+__version__ = "0.1.0" 

src/crypto_analysis/config/agents.yaml

@@ -0,0 +1,48 @@
+technical_strategist:
+  role: >
+    Bitcoin Technical Strategist
+  goal: >
+    Generate precise buy/sell signals for Bitcoin using 5-minute timeframe technical analysis
+    with RSI and Bollinger Bands indicators
+  backstory: >
+    You are a world-class technical analyst who specializes in cryptocurrency trading strategies.
+    You've developed a proprietary methodology combining RSI and Bollinger Bands on short timeframes
+    that consistently generates high-probability trading signals. Your expertise is in accurately
+    quantifying signal confidence and allocating portfolio percentages based on technical conditions.
+
+initial_analyst:
+  role: >
+    Bitcoin Market Analyst
+  goal: >
+    Provide comprehensive initial analysis of Bitcoin market conditions
+    using technical indicators, news, and market trends
+  backstory: >
+    You are a seasoned Bitcoin market analyst with a decade of experience in cryptocurrency trading.
+    Your expertise lies in combining technical analysis with fundamental and sentiment data to create
+    a holistic view of current market conditions. You're known for your attention to detail and
+    ability to identify key market signals from multiple data sources.
+
+reflection_analyst:
+  role: >
+    Bitcoin Market Strategist
+  goal: >
+    Critically evaluate the initial market analysis, challenge assumptions,
+    and identify additional factors that could influence Bitcoin's price
+  backstory: >
+    You are a strategic thinker with a background in both market analysis and behavioral finance.
+    Your strength is your ability to step back and see the bigger picture, identifying potential
+    blind spots in analysis and considering alternative viewpoints. You excel at questioning
+    assumptions and understanding how different market factors interact with each other.
+
+synthesis_analyst:
+  role: >
+    Bitcoin Decision Strategist
+  goal: >
+    Synthesize all available information to produce a final recommendation
+    with confidence score and suggested portfolio allocation
+  backstory: >
+    You are a decisive investment strategist with exceptional skills in weighing different
+    market perspectives and making clear, actionable recommendations. Your background spans
+    both traditional finance and cryptocurrency markets. You are known for your balanced judgment
+    and ability to quantify uncertainty into precise confidence levels that guide portfolio allocation
+    decisions. 

src/crypto_analysis/config/tasks.yaml

@@ -0,0 +1,96 @@
+technical_analysis:
+  description: >
+    Analyze Bitcoin using the 5-minute timeframe trading strategy based on RSI and Bollinger Bands.
+    Following these specific rules:
+    
+    1. Use the Technical Analysis Strategy Tool to fetch Bitcoin price data and calculate indicators
+    2. For Buy Signals:
+       - RSI below 40 (mildly oversold)
+       - Price near or touching the lower Bollinger Band (BBL)
+       - Preferably showing signs of bouncing up from the lower band
+    3. For Sell Signals:
+       - RSI above 60 (mildly overbought)
+       - Price near or touching the upper Bollinger Band (BBU)
+       - Preferably showing signs of reversing down from the upper band
+    4. If conditions don't clearly indicate buy or sell, recommend hold
+    
+    Provide exact numerical values for all indicators and precisely calculate the position of price
+    relative to the Bollinger Bands to ensure accurate signals.
+
+  expected_output: >
+    A precise technical analysis report that includes:
+    - Current Bitcoin price
+    - Current RSI value
+    - Current Bollinger Band values (upper, middle, lower)
+    - Clear signal: BUY, SELL, or HOLD
+    - Confidence level (0-100%)
+    - Recommended portfolio allocation percentage
+    - Detailed reasoning behind the signal
+    - Exact calculations showing how the signal was determined
+
+initial_analysis:
+  description: >
+    Conduct an initial analysis of Bitcoin's current market conditions by examining technical indicators,
+    sentiment from news and social media, overall market context, and the technical strategy signal. You must:
+    1. Consider the technical trading signal from the 5-minute timeframe strategy
+    2. Analyze broader technical indicators beyond the 5-minute timeframe
+    3. Review recent news and sentiment to gauge market perception
+    4. Consider broader cryptocurrency market trends that might impact Bitcoin
+    5. Determine if news and broader market trends support or contradict the trading signal
+
+  expected_output: >
+    A comprehensive initial market analysis report that includes:
+    - Current Bitcoin price and recent price action
+    - An assessment of the technical trading signal's validity in the current market
+    - Additional technical indicator readings and what they suggest
+    - Market sentiment based on news analysis
+    - Whether the news sentiment aligns with or contradicts the technical signals
+    - Key market factors currently influencing Bitcoin
+    - Contextual data from the broader cryptocurrency market
+
+reflection:
+  description: >
+    Review both the technical trading signal and the initial market analysis to provide a critical reflection.
+    Your task is to:
+    1. Evaluate if the technical strategy signal (from the 5-minute RSI/BB strategy) is likely reliable
+    2. Identify potential limitations of the short-timeframe technical strategy
+    3. Assess if important market factors were missed in the initial analysis
+    4. Consider how news sentiment might override or reinforce the technical signals
+    5. Analyze if the recommended portfolio allocation from the technical strategy is appropriate
+    6. Suggest additional data or market factors that should be considered
+
+  expected_output: >
+    A reflective assessment that:
+    - Critically evaluates the strengths and limitations of the 5-minute technical strategy
+    - Addresses the appropriateness of the confidence level assigned by the technical strategy
+    - Evaluates if the initial analysis properly integrated the technical signal with other factors
+    - Identifies any contradictory signals between technical analysis and news/sentiment
+    - Highlights additional market factors that could affect Bitcoin price in the short term
+    - Suggests improvements to the technical strategy or initial analysis approach
+
+final_synthesis:
+  description: >
+    Synthesize all three analyses (technical strategy, initial analysis, and reflection) to produce
+    a final recommendation. Based on all available information, you should:
+    1. Determine if the technical trading signal should be followed, modified, or rejected
+    2. Consider how news sentiment and broader market context affect the signal's reliability
+    3. Address points raised in the reflection about potential limitations or blind spots
+    4. Make a final buy, sell, or hold recommendation
+    5. Assign your own confidence level that may differ from the technical strategy
+    6. Adjust the recommended portfolio allocation if necessary
+    7. Provide a comprehensive explanation for your final decision
+
+  expected_output: >
+    A final recommendation that includes:
+    - Current Bitcoin Price
+    - Original Technical Signal (buy, sell, or hold)
+    - Technical Signal Confidence (from strategy)
+    - Final Recommendation (buy, sell, or hold) - may differ from technical signal
+    - Final Confidence Score (0-100%)
+    - Final Portfolio Allocation Percentage
+    - Time horizon for the recommendation
+    - Reasoning that explicitly addresses:
+      * Why you followed or deviated from the technical signal
+      * How news and sentiment influenced your decision
+      * How you addressed concerns raised in the reflection
+      * Key risks that could invalidate your recommendation 

src/crypto_analysis/crew.py

@@ -0,0 +1,751 @@
+import re
+import logging
+import functools
+from typing import Dict, Any
+from crewai import Agent, Crew, Process, Task
+from dotenv import load_dotenv
+load_dotenv()
+
+import os
+from src.crypto_analysis.tools.bitcoin_tools import YahooBitcoinDataTool, RealBitcoinNewsTool
+from src.crypto_analysis.tools.technical_tools import TechnicalAnalysisStrategy
+from src.crypto_analysis.tools.order_tools import AlpacaCryptoOrderTool
+from src.crypto_analysis.tools.yahoo_tools import YahooCryptoMarketTool
+
+# Import your preferred LLM
+import openai
+from langchain_openai import ChatOpenAI
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("bitcoin_crew")
+
+# Set up OpenAI client
+openai.api_key = os.getenv("OPENAI_API_KEY")
+llm = ChatOpenAI(model="gpt-4o") 
+
+class BitcoinAnalysisCrew:
+    """A simplified Bitcoin analysis crew with reflection and synthesis"""
+    
+    def __init__(self, timeframe="5m", max_allocation=100):
+        """
+        Initialize the Bitcoin analysis crew
+        
+        Args:
+            timeframe (str): Timeframe for technical analysis (e.g., "1m", "5m", "15m", "1h", "4h", "1d")
+            max_allocation (int): Maximum portfolio allocation percentage allowed (1-100)
+        """
+        # Store user preferences
+        self.timeframe = timeframe
+        self.max_allocation = min(max(1, max_allocation), 100)  # Ensure between 1-100
+        
+        self.bitcoin_data_tool = YahooBitcoinDataTool(
+            max_retries=3,
+            backoff_factor=2.0,
+            timeout=30,
+            cache_duration_minutes=15,
+            timeframe=self.timeframe  # Pass timeframe to data tool
+        )
+        self.bitcoin_news_tool = RealBitcoinNewsTool()
+        self.technical_strategy_tool = TechnicalAnalysisStrategy(
+            timeframe=self.timeframe  # Pass timeframe to technical strategy tool
+        )
+        self.order_tool = AlpacaCryptoOrderTool()
+        self.crypto_market_tool = YahooCryptoMarketTool(
+            max_retries=3,
+            backoff_factor=2.0,
+            timeout=30,
+            cache_duration_minutes=30
+        )
+        
+        # Save agent instances for reuse
+        self._technical_agent = None
+        self._analyst_agent = None
+        self._reflection_agent = None
+        self._synthesis_agent = None
+        
+        # Track tool states for error handling
+        self.tool_states = {
+            "bitcoin_data": {"status": "not_started", "error": None},
+            "bitcoin_news": {"status": "not_started", "error": None},
+            "technical_strategy": {"status": "not_started", "error": None},
+            "crypto_market": {"status": "not_started", "error": None},
+            "order_tool": {"status": "not_started", "error": None}
+        }
+        
+        # Patch tools for monitoring
+        self._patch_tools_for_monitoring()
+        
+        logger.info(f"Initialized Bitcoin analysis crew with timeframe={timeframe}, max_allocation={max_allocation}%")
+    
+    def create_technical_analyst_agent(self) -> Agent:
+        """Creates a Technical Analysis agent for Bitcoin"""
+        if self._technical_agent is not None:
+            return self._technical_agent
+            
+        self._technical_agent = Agent(
+            name="Bitcoin Technical Strategist",
+            role="Bitcoin technical trading strategist",
+            goal=f"Analyze Bitcoin technical indicators using {self.timeframe} timeframe data to generate accurate buy/sell signals",
+            backstory=f"""You are an expert in technical analysis for Bitcoin trading. 
+            You specialize in analyzing {self.timeframe} price patterns using key indicators 
+            like RSI and Bollinger Bands to identify high-probability trading opportunities.
+            You pride yourself on providing clear, data-driven trading signals 
+            with confidence levels and precise allocation recommendations.
+            
+            IMPORTANT: The user has set a maximum allocation of {self.max_allocation}% of their portfolio.
+            You MUST NOT recommend allocations higher than this, regardless of how strong the signal is.""",
+            verbose=True,
+            llm=llm,
+            tools=[self.technical_strategy_tool]
+        )
+        return self._technical_agent
+    
+    def create_analyst_agent(self) -> Agent:
+        """Creates a Bitcoin analyst agent for initial analysis"""
+        if self._analyst_agent is not None:
+            return self._analyst_agent
+            
+        self._analyst_agent = Agent(
+            name="Bitcoin Initial Analyst",
+            role="Bitcoin technical analyst",
+            goal=f"Analyze Bitcoin technical data on {self.timeframe} timeframe, news, and technical strategy signals to provide a holistic assessment",
+            backstory=f"""You are a technical analyst with expertise in Bitcoin price patterns 
+            and market indicators on the {self.timeframe} timeframe. You focus on data-driven analysis while also incorporating 
+            news sentiment and technical trading signals from specialized strategy models.
+            
+            IMPORTANT: The user has set a maximum allocation of {self.max_allocation}% of their portfolio.
+            You MUST respect this limit in your analysis and recommendations.
+            
+            IMPORTANT: You must check for error reports in tool outputs. If a tool returns an 'error' field, 
+            you should acknowledge the error, explain its potential impact on your analysis, and adjust your 
+            approach accordingly. Do not simply proceed as if the tool succeeded.
+            
+            If multiple tools return errors, focus on what data is available and explicitly state the limitations
+            of your analysis due to missing data.""",
+            verbose=True,
+            llm=llm,
+            tools=[self.bitcoin_data_tool, self.bitcoin_news_tool, self.crypto_market_tool]
+        )
+        return self._analyst_agent
+    
+    def create_reflection_agent(self) -> Agent:
+        """Creates a reflection agent to evaluate the initial analysis"""
+        if self._reflection_agent is not None:
+            return self._reflection_agent
+            
+        self._reflection_agent = Agent(
+            name="Bitcoin Reflection Analyst",
+            role="Bitcoin market sentiment analyst",
+            goal="Evaluate initial analysis and technical strategy signals to provide a market sentiment perspective",
+            backstory=f"""You are a market sentiment specialist who analyzes news and social trends 
+            to determine broader market sentiment around Bitcoin. You also consider technical signals 
+            and initial analysis to form a comprehensive view of market conditions.
+            
+            IMPORTANT: The user has set a maximum allocation of {self.max_allocation}% of their portfolio.
+            Any recommendation you make should respect this limit.
+            
+            IMPORTANT: If you encounter errors or limitations in earlier analyses due to tool failures,
+            acknowledge these limitations and adapt your reflection accordingly. Be explicit about how
+            missing data affects the reliability of your assessment.""",
+            verbose=True,
+            llm=llm,
+            tools=[self.bitcoin_news_tool]
+        )
+        return self._reflection_agent
+    
+    def create_synthesis_agent(self) -> Agent:
+        """Creates a synthesis agent to provide final recommendation"""
+        if self._synthesis_agent is not None:
+            return self._synthesis_agent
+            
+        self._synthesis_agent = Agent(
+            name="Bitcoin Synthesis Analyst",
+            role="Senior cryptocurrency investment advisor",
+            goal="Synthesize all analysis (technical strategy, initial, and reflection) to provide final recommendation and execute trades with comprehensive reasoning",
+            backstory=f"""You are a seasoned investment advisor who specializes in cryptocurrency.
+            You analyze technical signals, market sentiment, and fundamental factors to provide 
+            balanced investment advice with high confidence levels and specific allocation percentages.
+            You can also execute trades on behalf of clients based on your final recommendations.
+            
+            You are known for providing highly detailed and comprehensive analysis reports that break down
+            each factor that influenced your decision, quantifying the impact of each element on your final recommendation.
+            
+            IMPORTANT: The user has set a maximum allocation of {self.max_allocation}% of their portfolio.
+            You MUST NOT exceed this limit in your allocation recommendation, regardless of signal strength.
+            
+            IMPORTANT: You must acknowledge and account for any data limitations or tool failures in your synthesis.
+            If there were errors in previous analyses, explicitly state how these affect your final recommendation's
+            reliability and adjust your confidence levels accordingly.
+            
+            IMPORTANT TOOL USAGE - When using the Alpaca Crypto Order Tool:
+            1. For BUY orders, use: 
+               {{"action": "buy", "symbol": "BTC/USD", "allocation_percentage": X, "confidence": Y}}
+               where X is your recommended allocation percentage (NOT EXCEEDING {self.max_allocation}%)
+               The tool will automatically convert the allocation_percentage into the appropriate BTC quantity.
+            2. For SELL orders, use:
+               {{"action": "sell", "symbol": "BTC/USD", "allocation_percentage": X, "confidence": Y}}
+               where X is your recommended allocation percentage (NOT EXCEEDING {self.max_allocation}%)
+               The tool will automatically calculate how many BTC to sell based on your portfolio.
+            3. For checking account (HOLD), use:
+               {{"action": "check"}}
+            """,
+            verbose=True,
+            llm=llm,
+            tools=[self.order_tool]
+        )
+        return self._synthesis_agent
+    
+    def create_technical_strategy_task(self, strategy_text=None) -> Task:
+        """Creates technical strategy analysis task"""
+        # Generate description using provided strategy or default
+        if strategy_text:
+            description = f"""Analyze Bitcoin's technical indicators on the {self.timeframe} timeframe to generate a buy/sell signal based on the following strategy:
+            
+            {strategy_text}
+            
+            Use the Technical Analysis Strategy Tool to get current indicator values and analyze them according to the strategy.
+            
+            IMPORTANT: The user has set a maximum allocation of {self.max_allocation}% of their portfolio.
+            Do NOT recommend allocations above this limit, regardless of how strong the signal is.
+            
+            IMPORTANT: If the tool returns an error (look for an "error" field in the response),
+            you must:
+            1. Acknowledge the error in your analysis
+            2. Explain how it impacts your ability to provide a reliable signal
+            3. If possible, make a recommendation based on any partial data available
+            4. Set confidence lower to reflect the uncertainty
+            
+            Your analysis should include:
+            - Clear buy, sell, or hold signal
+            - Confidence level as a percentage (0-100%)
+            - Recommended portfolio allocation percentage (maximum {self.max_allocation}%)
+            - Detailed reasoning explaining the signal
+            - Current values for all relevant indicators
+            - Any error messages or data limitations
+            """
+        else:
+            # Fall back to default strategy if none provided
+            description = f"""Analyze Bitcoin's technical indicators on the {self.timeframe} timeframe to generate a buy/sell signal.
+            
+            1. Use the Technical Analysis Strategy Tool to analyze RSI and Bollinger Bands on the {self.timeframe} timeframe
+            2. Evaluate if current conditions meet the criteria for a buy signal:
+               - RSI below 40
+               - Price near or touching the lower Bollinger Band
+               - Signs of a price bounce from the lower band
+            3. Evaluate if current conditions meet the criteria for a sell signal:
+               - RSI above 60
+               - Price near or touching the upper Bollinger Band
+               - Signs of price reversal from the upper band
+            4. If neither buy nor sell conditions are met, recommend hold
+            
+            IMPORTANT: The user has set a maximum allocation of {self.max_allocation}% of their portfolio.
+            Do NOT recommend allocations above this limit.
+            
+            IMPORTANT: If the tool returns an error (look for an "error" field in the response),
+            you must:
+            1. Acknowledge the error in your analysis
+            2. Explain how it impacts your ability to provide a reliable signal
+            3. If possible, make a recommendation based on any partial data available
+            4. Set confidence lower to reflect the uncertainty
+            
+            Your analysis should include:
+            - Clear buy, sell, or hold signal
+            - Confidence level as a percentage (0-100%)
+            - Recommended portfolio allocation percentage (not exceeding {self.max_allocation}%)
+            - Detailed reasoning explaining the signal
+            - Current values for all relevant indicators
+            - Any error messages or data limitations
+            """
+            
+        return Task(
+            description=description,
+            agent=self.create_technical_analyst_agent(),
+            expected_output="Technical strategy analysis with clear signal, confidence level, and allocation recommendation"
+        )
+    
+    def create_initial_task(self, technical_task) -> Task:
+        """Creates initial analysis task"""
+        return Task(
+            description="""Analyze Bitcoin's current market situation using price data, news, technical strategy signals, and broader crypto market context.
+            
+            1. Get the latest Bitcoin price data and identify the trend
+            2. Check recent news that might impact Bitcoin price
+            3. Consider the technical strategy signals provided
+            4. Analyze the broader cryptocurrency market context using the Yahoo Finance Crypto Market Tool
+            5. Provide an initial holistic assessment
+            
+            IMPORTANT: For each tool you use, check if there's an "error" field in the response.
+            If any tool returns an error:
+            1. Acknowledge the error explicitly
+            2. Explain how it affects your analysis
+            3. Adjust your conclusions accordingly
+            4. Use whatever partial data is available
+            
+            Your analysis should include:
+            - Current Bitcoin Price (if available)
+            - Recent Price Trend (bullish or bearish, if data available)
+            - Technical Signals (including those from the strategy)
+            - Broader Crypto Market Context (including BTC dominance and overall market trend, if available)
+            - Key News Impact
+            - Data Limitations (explain any missing or potentially unreliable data)
+            - How the news sentiment and market context align or conflict with technical signals
+            """,
+            agent=self.create_analyst_agent(),
+            context=[technical_task],
+            expected_output="Initial holistic assessment of Bitcoin's current market situation"
+        )
+    
+    def create_reflection_task(self, technical_task, initial_task) -> Task:
+        """Creates reflection task building on initial analysis"""
+        return Task(
+            description="""Review the technical strategy signals and initial Bitcoin analysis to add market sentiment perspective.
+            
+            1. Evaluate the news sentiment around Bitcoin using the Bitcoin News Tool
+            2. Consider if technical signals and initial analysis align with market sentiment
+            3. Identify any potential gaps or oversights in the technical strategy or initial analysis
+            4. Evaluate if the technical strategy confidence level seems appropriate given broader market context
+            
+            IMPORTANT: If you encounter errors from tools or limitations noted in the previous analyses,
+            acknowledge these explicitly and explain how they affect your assessment.
+            
+            Your reflection should include:
+            - Sentiment Assessment (positive, negative, or neutral)
+            - Agreement or Disagreement with Technical Strategy Signals
+            - Agreement or Disagreement with Initial Analysis
+            - Data Reliability Assessment (mention any tool errors or data limitations)
+            - Additional Insights Not Covered in Previous Analyses
+            """,
+            agent=self.create_reflection_agent(),
+            context=[technical_task, initial_task],
+            expected_output="Reflection on technical strategy and initial analysis with sentiment perspective"
+        )
+    
+    def create_synthesis_task(self, technical_task, initial_task, reflection_task) -> Task:
+        """Creates synthesis task for final recommendation"""
+        return Task(
+            description=f"""Synthesize all analyses (technical strategy, initial, and reflection) to provide a final investment recommendation and execute the trade.
+            
+            1. Consider the technical strategy signals (buy/sell/hold) with HIGH PRIORITY
+               - Use the technical strategy's confidence and allocation as a BASELINE 
+               - Adjust confidence based on any tool errors or data limitations noted
+            2. Evaluate the initial holistic assessment
+               - Pay special attention to the broader crypto market context and BTC dominance
+               - Consider how Bitcoin's performance compares to other cryptocurrencies
+            3. Incorporate the sentiment perspective from the reflection
+            4. Make a final recommendation that integrates all three perspectives
+               - If technical and news analyses conflict, split the difference
+               - NEVER output a confidence of 0% for a BUY or SELL signal
+               - If recommending BUY or SELL, the minimum confidence should be 30%
+               - If recommending BUY or SELL, the minimum allocation should be 5%
+               - The MAXIMUM allocation must NOT exceed {self.max_allocation}% (user's set limit)
+               - IMPORTANT: If there were significant tool errors, reduce confidence accordingly
+            5. Provide your own confidence level and allocation percentage
+            6. EXECUTE THE TRADE using the Alpaca Crypto Order Tool as the very last step:
+               - IMPORTANT: Always use the symbol format "BTC/USD" with the slash, not "BTCUSD"
+               - You MUST use allocation_percentage, which represents what percentage of the portfolio to allocate
+               - For BUY orders: The tool will convert the allocation_percentage into the appropriate BTC quantity
+                 Example: {{"action": "buy", "symbol": "BTC/USD", "allocation_percentage": N, "confidence": M}}
+                 Where N is between 5 and {self.max_allocation}, and M is between 30 and 100
+               - For SELL orders: The tool will calculate how many BTC to sell based on your allocation_percentage
+                 Example: {{"action": "sell", "symbol": "BTC/USD", "allocation_percentage": N, "confidence": M}}
+                 Where N is between 5 and {self.max_allocation}, and M is between 30 and 100
+               - For HOLD recommendation: Check the account status only
+                 Example: {{"action": "check"}}
+               - DO NOT try to calculate the exact BTC quantity yourself - the tool will do this automatically
+               - DO NOT include additional parameters beyond what's shown in the examples
+               - VERIFY that your input matches EXACTLY one of the example formats above
+               
+               EXAMPLES OF INCORRECT USAGE (DO NOT DO THESE):
+               - DO NOT use: {{"action": "buy", "quantity": 0.001}} ← Don't specify quantity directly
+               - DO NOT use: {{"action": "buy", "symbol...": 15, "confidence": 75}}  ← Missing quotes around symbol
+               - DO NOT use: {{"action": "buy", "symbol": "BTC/USD"}}  ← Missing allocation_percentage
+               - DO NOT use: {{"action": "buy", "symbol": "BTCUSD", "allocation_percentage": 15}}  ← Wrong symbol format
+               - DO NOT use: {{"action": "buy", "symbol": "BTC/USD", "quantity": 0.001, "allocation_percentage": 15}}  ← Using both quantity and allocation
+            
+            Your final recommendation must be EXTREMELY DETAILED and should include:
+            - Current Bitcoin Price: (latest price if available)
+            - Technical Signal: (from strategy: buy, sell, or hold)
+            - Technical Confidence: (from strategy: 0-100%)
+            - Technical Allocation: (from strategy: percentage)
+            - Tool Error Assessment: (explicitly describe any tool errors encountered in the analysis process and how they affected your recommendation)
+            - Data Reliability: (assess the reliability of the data used for this recommendation)
+            - Technical Analysis Summary: (detailed explanation of the technical indicators at {self.timeframe} timeframe)
+            - Initial Analysis Summary: (detailed explanation of the broader market context)
+            - Reflection Analysis Summary: (detailed explanation of market sentiment)
+            - Importance Weighting: (explicitly state how you weighted each analysis: technical, initial, and reflection)
+            - Impact of Technical Factors: (explicit percentage impact of technical factors on your decision, with detailed explanation)
+            - Impact of Market Context: (explicit percentage impact of market context on your decision, with detailed explanation)
+            - Impact of Sentiment: (explicit percentage impact of sentiment on your decision, with detailed explanation)
+            - Final Recommendation: (buy, sell, or hold)
+            - Final Confidence: (0-100%)
+            - Allocation Percentage: (how much of portfolio to allocate, NOT EXCEEDING {self.max_allocation}%)
+            - Detailed Reasoning: (comprehensive explanation of how you arrived at your final recommendation, including how you reconciled any conflicting signals)
+            - Market Outlook: (your assessment of the likely short-term direction of Bitcoin price)
+            - Risk Assessment: (evaluation of the risk associated with your recommendation)
+            - Trade Execution: (details of the order executed or account status check)
+            """,
+            agent=self.create_synthesis_agent(),
+            context=[technical_task, initial_task, reflection_task],
+            expected_output="Final Bitcoin investment recommendation with detailed analysis breakdown and trade execution details"
+        )
+    
+    def run_analysis(self, strategy_text=None, timeframe=None, max_allocation=None) -> Dict[str, Any]:
+        """
+        Run the Bitcoin analysis workflow with reflection and synthesis
+        
+        Args:
+            strategy_text: Custom trading strategy text from UI
+            timeframe: Optional override for analysis timeframe (e.g. "1m", "5m", "15m", "1h", "4h", "1d")
+            max_allocation: Optional override for maximum portfolio allocation percentage (1-100)
+            
+        Returns:
+            Dictionary with analysis results and trading recommendation
+        """
+        try:
+            # Update timeframe and max_allocation if provided
+            if timeframe is not None:
+                self.timeframe = timeframe
+                # Update tools with new timeframe
+                self.bitcoin_data_tool.timeframe = timeframe
+                self.technical_strategy_tool.timeframe = timeframe
+                logger.info(f"Updated timeframe for analysis to {timeframe}")
+                
+            if max_allocation is not None:
+                self.max_allocation = min(max(1, max_allocation), 100)  # Ensure between 1-100
+                logger.info(f"Updated maximum allocation to {self.max_allocation}%")
+            
+            logger.info(f"Starting Bitcoin analysis workflow with timeframe={self.timeframe}, max_allocation={self.max_allocation}%")
+            
+            # Reset tool states
+            for key in self.tool_states:
+                self.tool_states[key] = {"status": "not_started", "error": None}
+            
+            # Create tasks
+            logger.info("Creating tasks")
+            technical_task = self.create_technical_strategy_task(strategy_text)
+            initial_task = self.create_initial_task(technical_task)
+            reflection_task = self.create_reflection_task(technical_task, initial_task)
+            synthesis_task = self.create_synthesis_task(technical_task, initial_task, reflection_task)
+            
+            # Create the crew with all agents and tasks
+            logger.info("Creating crew")
+            crew = Crew(
+                agents=[
+                    self.create_technical_analyst_agent(),
+                    self.create_analyst_agent(),
+                    self.create_reflection_agent(),
+                    self.create_synthesis_agent()
+                ],
+                tasks=[technical_task, initial_task, reflection_task, synthesis_task],
+                verbose=True,
+                process=Process.sequential
+            )
+            
+            # Execute the workflow
+            logger.info("Executing crew workflow")
+            result = crew.kickoff()
+            
+            # Parse the result - convert CrewOutput to string first
+            result_str = str(result)
+            logger.info("Parsing analysis results")
+            parsed_result = self._parse_result(result_str)
+            
+            # Add tool state information to the result
+            parsed_result["tool_states"] = self.tool_states
+            
+            # Add analysis parameters
+            parsed_result["timeframe"] = self.timeframe
+            parsed_result["max_allocation"] = self.max_allocation
+            
+            # Cap allocation at max_allocation if needed
+            if parsed_result.get("allocation_percentage", 0) > self.max_allocation:
+                logger.warning(f"Capping allocation from {parsed_result['allocation_percentage']}% to {self.max_allocation}%")
+                parsed_result["allocation_percentage"] = self.max_allocation
+                parsed_result["portfolio_allocation"] = self.max_allocation
+            
+            # Log the summary of the result
+            logger.info(f"Analysis complete - Signal: {parsed_result['signal']}, Confidence: {parsed_result['confidence']}%, Allocation: {parsed_result.get('allocation_percentage', 0)}%")
+            
+            # Check for tool errors and add a summary
+            tool_errors = []
+            for tool_name, state in self.tool_states.items():
+                if state.get("status") == "error" and state.get("error"):
+                    tool_errors.append(f"{tool_name}: {state['error']}")
+            
+            if tool_errors:
+                error_summary = "; ".join(tool_errors)
+                parsed_result["tool_error_summary"] = error_summary
+                logger.warning(f"Tool errors occurred during analysis: {error_summary}")
+            
+            return parsed_result
+        
+        except Exception as e:
+            logger.error(f"Error in Bitcoin analysis workflow: {str(e)}", exc_info=True)
+            return {
+                "error": str(e),
+                "signal": "hold",  # Default to hold on error
+                "confidence": 0,
+                "portfolio_allocation": 0,
+                "allocation_percentage": 0,
+                "reasoning": f"Error in analysis: {str(e)}",
+                "tool_states": self.tool_states,
+                "timeframe": self.timeframe,
+                "max_allocation": self.max_allocation
+            }
+    
+    def _parse_result(self, result: str) -> Dict[str, Any]:
+        """
+        Parse the analysis result from text format
+        
+        Args:
+            result: The text result from the crew
+            
+        Returns:
+            Structured dictionary with recommendation details
+        """
+        # Default values
+        parsed = {
+            "signal": "hold",
+            "confidence": 0,
+            "allocation_percentage": 0,
+            "reasoning": "Analysis incomplete",
+            "raw_result": result
+        }
+        
+        try:
+            logger.info("Parsing result from crew output")
+            
+            # Extract recommendation (buy, sell, hold)
+            final_rec_match = re.search(r'final\s+recommendation:?\s*(buy|sell|hold)', result.lower())
+            if final_rec_match:
+                parsed["signal"] = final_rec_match.group(1).lower()
+            elif "buy" in result.lower():
+                parsed["signal"] = "buy"
+            elif "sell" in result.lower():
+                parsed["signal"] = "sell"
+            else:
+                parsed["signal"] = "hold"
+            
+            # Extract confidence percentage using improved pattern matching
+            # Try multiple confidence patterns
+            confidence_patterns = [
+                r'final\s+confidence:?\s*(\d+)',
+                r'confidence:?\s*(\d+)',
+                r'confidence:?\s*(\d+)%',
+                r'with\s+(\d+)%\s+confidence'
+            ]
+            
+            for pattern in confidence_patterns:
+                confidence_match = re.search(pattern, result.lower())
+                if confidence_match:
+                    parsed["confidence"] = int(confidence_match.group(1))
+                    break
+            
+            # Set minimum confidence for buy/sell signals
+            if parsed["signal"] in ["buy", "sell"] and parsed["confidence"] < 30:
+                parsed["confidence"] = 30
+            
+            # Extract allocation percentage with improved patterns
+            allocation_patterns = [
+                r'allocation\s+percentage:?\s*(\d+)',
+                r'allocation:?\s*(\d+)',
+                r'allocation:?\s*(\d+)%',
+                r'allocate\s+(\d+)%'
+            ]
+            
+            for pattern in allocation_patterns:
+                allocation_match = re.search(pattern, result.lower())
+                if allocation_match:
+                    parsed["allocation_percentage"] = int(allocation_match.group(1))
+                    break
+            
+            # Set minimum allocation for buy/sell signals
+            if parsed["signal"] in ["buy", "sell"] and parsed["allocation_percentage"] < 5:
+                parsed["allocation_percentage"] = 5
+            
+            # Extract data reliability assessment if available
+            data_reliability_match = re.search(r'data\s+reliability:?\s*(.+?)(?:\n\n|\Z|technical\s+analysis)', result, re.IGNORECASE | re.DOTALL)
+            if data_reliability_match:
+                parsed["data_reliability"] = data_reliability_match.group(1).strip()
+                
+            # Extract tool error assessment if available
+            tool_error_match = re.search(r'tool\s+error\s+assessment:?\s*(.+?)(?:\n\n|\Z|data\s+reliability)', result, re.IGNORECASE | re.DOTALL)
+            if tool_error_match:
+                parsed["tool_error_assessment"] = tool_error_match.group(1).strip()
+            
+            # Extract reasoning if available - try to get the detailed reasoning section first
+            detailed_reasoning_match = re.search(r'detailed\s+reasoning:?\s*(.+?)(?:\n\n|\Z|market\s+outlook)', result, re.IGNORECASE | re.DOTALL)
+            if detailed_reasoning_match:
+                parsed["reasoning"] = detailed_reasoning_match.group(1).strip()
+            else:
+                reasoning_match = re.search(r'reasoning:?\s*(.+?)(?:\n\n|\Z)', result, re.IGNORECASE | re.DOTALL)
+                if reasoning_match:
+                    parsed["reasoning"] = reasoning_match.group(1).strip()
+                else:
+                    # Try to extract any paragraph that looks like reasoning
+                    paragraphs = result.split('\n\n')
+                    for paragraph in paragraphs:
+                        if len(paragraph) > 100 and not paragraph.startswith('-'):
+                            parsed["reasoning"] = paragraph.strip()
+                            break
+            
+            # Extract detailed analysis sections if available
+            tech_analysis_match = re.search(r'technical\s+analysis\s+summary:?\s*(.+?)(?:\n\n|\Z|initial\s+analysis)', result, re.IGNORECASE | re.DOTALL)
+            if tech_analysis_match:
+                parsed["technical_analysis"] = tech_analysis_match.group(1).strip()
+                
+            initial_analysis_match = re.search(r'initial\s+analysis\s+summary:?\s*(.+?)(?:\n\n|\Z|reflection\s+analysis)', result, re.IGNORECASE | re.DOTALL)
+            if initial_analysis_match:
+                parsed["initial_analysis"] = initial_analysis_match.group(1).strip()
+                
+            reflection_analysis_match = re.search(r'reflection\s+analysis\s+summary:?\s*(.+?)(?:\n\n|\Z|importance\s+weighting)', result, re.IGNORECASE | re.DOTALL)
+            if reflection_analysis_match:
+                parsed["reflection_analysis"] = reflection_analysis_match.group(1).strip()
+                
+            impact_tech_match = re.search(r'impact\s+of\s+technical\s+factors:?\s*(.+?)(?:\n\n|\Z|impact\s+of\s+market)', result, re.IGNORECASE | re.DOTALL)
+            if impact_tech_match:
+                parsed["impact_technical"] = impact_tech_match.group(1).strip()
+                
+            impact_market_match = re.search(r'impact\s+of\s+market\s+context:?\s*(.+?)(?:\n\n|\Z|impact\s+of\s+sentiment)', result, re.IGNORECASE | re.DOTALL)
+            if impact_market_match:
+                parsed["impact_market"] = impact_market_match.group(1).strip()
+                
+            impact_sentiment_match = re.search(r'impact\s+of\s+sentiment:?\s*(.+?)(?:\n\n|\Z|final\s+recommendation)', result, re.IGNORECASE | re.DOTALL)
+            if impact_sentiment_match:
+                parsed["impact_sentiment"] = impact_sentiment_match.group(1).strip()
+                
+            market_outlook_match = re.search(r'market\s+outlook:?\s*(.+?)(?:\n\n|\Z|risk\s+assessment)', result, re.IGNORECASE | re.DOTALL)
+            if market_outlook_match:
+                parsed["market_outlook"] = market_outlook_match.group(1).strip()
+                
+            risk_assessment_match = re.search(r'risk\s+assessment:?\s*(.+?)(?:\n\n|\Z|trade\s+execution)', result, re.IGNORECASE | re.DOTALL)
+            if risk_assessment_match:
+                parsed["risk_assessment"] = risk_assessment_match.group(1).strip()
+            
+            # Extract order execution details
+            # Look for a section that contains order execution details
+            execution_section_pattern = r'trade\s+execution:?\s*(.+?)(?:\n\n|\Z)'
+            execution_match = re.search(execution_section_pattern, result, re.IGNORECASE | re.DOTALL)
+            
+            if execution_match:
+                execution_text = execution_match.group(1).strip()
+                parsed["order_execution_text"] = execution_text
+                
+                # Try to extract order details if available
+                order_id_match = re.search(r'order\s+id:?\s*([a-f0-9-]+)', execution_text, re.IGNORECASE)
+                if order_id_match:
+                    # This likely contains structured order info
+                    parsed["order_execution"] = {
+                        "order_id": order_id_match.group(1),
+                        "symbol": re.search(r'symbol:?\s*([A-Z/]+)', execution_text, re.IGNORECASE).group(1) if re.search(r'symbol:?\s*([A-Z/]+)', execution_text, re.IGNORECASE) else "BTC/USD",
+                        "side": re.search(r'side:?\s*(\w+)', execution_text, re.IGNORECASE).group(1) if re.search(r'side:?\s*(\w+)', execution_text, re.IGNORECASE) else parsed["signal"],
+                        "quantity": re.search(r'quantity:?\s*([\d.]+)', execution_text, re.IGNORECASE).group(1) if re.search(r'quantity:?\s*([\d.]+)', execution_text, re.IGNORECASE) else "unknown",
+                        "status": re.search(r'status:?\s*(\w+)', execution_text, re.IGNORECASE).group(1) if re.search(r'status:?\s*(\w+)', execution_text, re.IGNORECASE) else "unknown",
+                        "success": True
+                    }
+                elif "check" in execution_text.lower() and "account" in execution_text.lower():
+                    # This is an account check (for hold signal)
+                    # Extract any account details if available
+                    cash_match = re.search(r'cash:?\s*([\d.]+)', execution_text, re.IGNORECASE)
+                    equity_match = re.search(r'equity:?\s*([\d.]+)', execution_text, re.IGNORECASE)
+                    
+                    account_info = "Account check completed"
+                    if cash_match:
+                        account_info += f", Cash: ${cash_match.group(1)}"
+                    if equity_match:
+                        account_info += f", Equity: ${equity_match.group(1)}"
+                        
+                    parsed["order_execution"] = account_info
+                elif "failed" in execution_text.lower() or "error" in execution_text.lower():
+                    # This is a failed order
+                    error_message = "Unknown error"
+                    error_match = re.search(r'error:?\s*(.+?)(?:\n|\Z)', execution_text, re.IGNORECASE)
+                    if error_match:
+                        error_message = error_match.group(1).strip()
+                        
+                    parsed["order_execution"] = {
+                        "success": False,
+                        "error": error_message
+                    }
+                else:
+                    # Just include the raw text if we can't parse it
+                    parsed["order_execution"] = execution_text
+            
+            # Add portfolio allocation for backward compatibility
+            parsed["portfolio_allocation"] = parsed["allocation_percentage"]
+            
+            logger.info(f"Successfully parsed result: signal={parsed['signal']}, confidence={parsed['confidence']}%, allocation={parsed['allocation_percentage']}%")
+            return parsed
+            
+        except Exception as e:
+            logger.error(f"Error parsing result: {str(e)}", exc_info=True)
+            parsed["reasoning"] = f"Error parsing result: {str(e)}"
+            return parsed 
+
+    def track_tool_call(self, tool_name: str, response: Dict[str, Any]) -> None:
+        """
+        Track a tool call and update its state
+        
+        Args:
+            tool_name: Name of the tool being called
+            response: Response from the tool call
+        """
+        # Make sure the tool exists in our state tracking
+        if tool_name not in self.tool_states:
+            self.tool_states[tool_name] = {"status": "not_started", "error": None}
+        
+        # Check if the response contains an error
+        if "error" in response:
+            self.tool_states[tool_name]["status"] = "error"
+            self.tool_states[tool_name]["error"] = response["error"]
+            logger.warning(f"Tool '{tool_name}' reported an error: {response['error']}")
+        else:
+            self.tool_states[tool_name]["status"] = "success"
+            self.tool_states[tool_name]["error"] = None
+            logger.info(f"Tool '{tool_name}' executed successfully")
+
+    # Monkey patch the tool _run methods to track errors
+    def _patch_tools_for_monitoring(self) -> None:
+        """
+        Patch tool _run methods to track their execution status
+        """
+        for tool_name, tool in [
+            ("bitcoin_data", self.bitcoin_data_tool),
+            ("bitcoin_news", self.bitcoin_news_tool), 
+            ("technical_strategy", self.technical_strategy_tool),
+            ("crypto_market", self.crypto_market_tool),
+            ("order_tool", self.order_tool)
+        ]:
+            # Create and apply the wrapper immediately with the current values
+            # This ensures each closure gets its own copy of tool_name and original_run
+            def patch_tool(current_tool_name, current_tool):
+                original_run = current_tool._run
+                
+                @functools.wraps(original_run)
+                def wrapped_run(*args, **kwargs):
+                    try:
+                        # Update tool state to running
+                        self.tool_states[current_tool_name]["status"] = "running"
+                        
+                        # Call the original function
+                        result = original_run(*args, **kwargs)
+                        
+                        # Track the result
+                        self.track_tool_call(current_tool_name, result)
+                        
+                        return result
+                    except Exception as e:
+                        # Update tool state to error
+                        self.tool_states[current_tool_name]["status"] = "error"
+                        self.tool_states[current_tool_name]["error"] = str(e)
+                        logger.error(f"Exception in tool '{current_tool_name}': {str(e)}", exc_info=True)
+                        
+                        # Return an error response
+                        return {"error": f"Exception in tool execution: {str(e)}"}
+                
+                # Apply the wrapped function to this tool
+                current_tool._run = wrapped_run
+            
+            # Call the patching function with the current values
+            patch_tool(tool_name, tool) 

src/crypto_analysis/main.py

@@ -0,0 +1,310 @@
+import os
+import sys
+import json
+import logging
+import traceback
+from datetime import datetime
+from typing import Dict, Any
+
+from dotenv import load_dotenv
+load_dotenv()
+
+from src.crypto_analysis.crew import BitcoinAnalysisCrew
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler(os.path.join('logs', f'bitcoin_analysis_{datetime.now().strftime("%Y%m%d")}.log'))
+    ]
+)
+logger = logging.getLogger("bitcoin_analysis")
+
+# Ensure logs directory exists
+os.makedirs('logs', exist_ok=True)
+
+def run() -> Dict[str, Any]:
+    """
+    Run the Bitcoin analysis crew and return the results
+    
+    Returns:
+        Dictionary with analysis results
+    """
+    logger.info("Starting Bitcoin Price Sentiment Analysis")
+    print("## Starting Bitcoin Price Sentiment Analysis")
+    print("## " + "=" * 50)
+    
+    try:
+        # Create and run the Bitcoin analysis crew
+        bitcoin_crew = BitcoinAnalysisCrew()
+        result = bitcoin_crew.run_analysis()
+        
+        # Check for errors
+        if "error" in result:
+            logger.error(f"Error in Bitcoin analysis: {result['error']}")
+            print(f"## ERROR: {result['error']}")
+        
+        return result
+    except Exception as e:
+        error_traceback = traceback.format_exc()
+        logger.error(f"Unexpected error in run(): {str(e)}\n{error_traceback}")
+        return {
+            "error": str(e),
+            "traceback": error_traceback,
+            "signal": "hold",  # Default to hold on error
+            "confidence": 0,
+            "portfolio_allocation": 0,
+            "reasoning": f"Unexpected error: {str(e)}"
+        }
+
+def save_result(result: Dict[str, Any], output_dir: str = "results") -> str:
+    """
+    Save analysis result to a JSON file
+    
+    Args:
+        result: The analysis result to save
+        output_dir: Directory to save results in
+        
+    Returns:
+        Path to the saved file
+    """
+    try:
+        # Create output directory if it doesn't exist
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+        
+        # Generate filename with timestamp
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"bitcoin_analysis_{timestamp}.json"
+        filepath = os.path.join(output_dir, filename)
+        
+        # Save result as JSON
+        with open(filepath, "w") as f:
+            json.dump(result, f, indent=2)
+        
+        logger.info(f"Saved analysis result to {filepath}")
+        return filepath
+    except Exception as e:
+        error_traceback = traceback.format_exc()
+        logger.error(f"Error saving result: {str(e)}\n{error_traceback}")
+        
+        # Try to save to a fallback location
+        try:
+            fallback_path = os.path.join(".", f"bitcoin_analysis_error_{timestamp}.json")
+            with open(fallback_path, "w") as f:
+                json.dump(result, f, indent=2)
+            logger.info(f"Saved analysis result to fallback location {fallback_path}")
+            return fallback_path
+        except:
+            logger.error("Failed to save result even to fallback location")
+            return "ERROR_SAVING_RESULT"
+
+def format_output(result: Dict[str, Any]) -> str:
+    """
+    Format the analysis result as a readable string
+    
+    Args:
+        result: The analysis result to format
+        
+    Returns:
+        Formatted string representation
+    """
+    signal = result.get("signal", "hold").upper()
+    confidence = result.get("confidence", 0)
+    allocation = result.get("portfolio_allocation", 0)
+    reasoning = result.get("reasoning", "No reasoning provided")
+    
+    # Check for tool errors
+    tool_errors = result.get("tool_error_summary", "")
+    error_message = ""
+    if tool_errors:
+        error_message = f"## TOOL ERRORS DETECTED\n{tool_errors}\n\n"
+    
+    # Check for data reliability information
+    data_reliability = result.get("data_reliability", "")
+    reliability_message = ""
+    if data_reliability:
+        reliability_message = f"## DATA RELIABILITY\n{data_reliability}\n\n"
+    
+    output = [
+        "## BITCOIN TRADING RECOMMENDATION",
+        "## " + "=" * 50,
+        f"SIGNAL:       {signal}",
+        f"CONFIDENCE:   {confidence}%",
+        f"ALLOCATION:   {allocation}% of portfolio",
+        ""
+    ]
+    
+    if error_message:
+        output.append(error_message)
+    
+    if reliability_message:
+        output.append(reliability_message)
+    
+    output.extend([
+        "## REASONING",
+        reasoning
+    ])
+    
+    # Add market outlook if available
+    market_outlook = result.get("market_outlook", "")
+    if market_outlook:
+        output.extend([
+            "",
+            "## MARKET OUTLOOK",
+            market_outlook
+        ])
+    
+    # Add risk assessment if available
+    risk_assessment = result.get("risk_assessment", "")
+    if risk_assessment:
+        output.extend([
+            "",
+            "## RISK ASSESSMENT",
+            risk_assessment
+        ])
+    
+    # Add trade execution details if available
+    order_execution = result.get("order_execution_text", "")
+    if order_execution:
+        output.extend([
+            "",
+            "## TRADE EXECUTION",
+            order_execution
+        ])
+    
+    return "\n".join(output)
+
+def monitor_mode():
+    """
+    Run Bitcoin analysis in monitoring mode (continuous analysis at intervals)
+    """
+    from time import sleep
+    
+    logger.info("Starting Bitcoin Price Sentiment Analysis in Monitoring Mode")
+    print("## Starting Bitcoin Price Sentiment Analysis in Monitoring Mode")
+    print("## Analysis will run once every 4 hours")
+    print("## Press Ctrl+C to exit")
+    print("## " + "=" * 50)
+    
+    interval_seconds = 4 * 60 * 60  # 4 hours
+    try:
+        run_count = 0
+        error_count = 0
+        max_consecutive_errors = 3
+        
+        while True:
+            # Run analysis
+            start_time = datetime.now()
+            print(f"\n## Running analysis at {start_time.strftime('%Y-%m-%d %H:%M:%S')}")
+            logger.info(f"Running analysis #{run_count + 1} at {start_time.strftime('%Y-%m-%d %H:%M:%S')}")
+            
+            try:
+                result = run()
+                run_count += 1
+                
+                # Check for errors
+                if "error" in result:
+                    error_count += 1
+                    print(f"## WARNING: Analysis completed with errors ({error_count}/{max_consecutive_errors})")
+                    logger.warning(f"Analysis completed with errors: {result['error']}")
+                    
+                    # If we have too many consecutive errors, increase sleep time to back off
+                    if error_count >= max_consecutive_errors:
+                        print(f"## Too many consecutive errors. Backing off...")
+                        logger.warning(f"Too many consecutive errors ({error_count}). Backing off...")
+                        interval_seconds = min(interval_seconds * 2, 12 * 60 * 60)  # Max 12 hours
+                else:
+                    # Reset error count if successful
+                    error_count = 0
+                    # Reset interval if it was increased
+                    interval_seconds = 4 * 60 * 60
+                
+                filepath = save_result(result)
+                
+                print(format_output(result))
+                print(f"\n## Results saved to {filepath}")
+                
+                # Calculate sleep time (accounting for analysis duration)
+                elapsed = (datetime.now() - start_time).total_seconds()
+                sleep_time = max(interval_seconds - elapsed, 0)
+                
+                print(f"\n## Next analysis in {sleep_time/60/60:.2f} hours")
+                logger.info(f"Next analysis in {sleep_time/60/60:.2f} hours")
+                sleep(sleep_time)
+                
+            except Exception as e:
+                error_traceback = traceback.format_exc()
+                error_count += 1
+                logger.error(f"Error in monitoring loop: {str(e)}\n{error_traceback}")
+                print(f"## ERROR in monitoring loop: {str(e)}")
+                
+                # Save error information
+                error_result = {
+                    "error": str(e),
+                    "traceback": error_traceback,
+                    "signal": "hold",
+                    "confidence": 0,
+                    "portfolio_allocation": 0,
+                    "reasoning": f"Error in monitoring loop: {str(e)}"
+                }
+                save_result(error_result)
+                
+                # If we have too many consecutive errors, increase sleep time
+                if error_count >= max_consecutive_errors:
+                    print(f"## Too many consecutive errors ({error_count}/{max_consecutive_errors}). Backing off...")
+                    logger.warning(f"Too many consecutive errors ({error_count}). Backing off...")
+                    interval_seconds = min(interval_seconds * 2, 12 * 60 * 60)  # Max 12 hours
+                
+                # Sleep a shorter time before retrying
+                sleep_time = min(interval_seconds / 4, 60 * 60)  # Min of 1/4 regular interval or 1 hour
+                print(f"## Retrying in {sleep_time/60:.0f} minutes...")
+                logger.info(f"Retrying in {sleep_time/60:.0f} minutes")
+                sleep(sleep_time)
+            
+    except KeyboardInterrupt:
+        logger.info("Monitoring stopped by user")
+        print("\n## Monitoring stopped by user")
+        return
+
+def train():
+    """
+    Train the crew for a given number of iterations
+    """
+    try:
+        iterations = int(sys.argv[2]) if len(sys.argv) > 2 else 1
+        logger.info(f"Training Bitcoin Analysis Crew for {iterations} iterations")
+        print(f"## Training Bitcoin Analysis Crew for {iterations} iterations")
+        
+        bitcoin_crew = BitcoinAnalysisCrew()
+        bitcoin_crew.crew().train(n_iterations=iterations)
+        
+    except Exception as e:
+        error_traceback = traceback.format_exc()
+        logger.error(f"Error training crew: {str(e)}\n{error_traceback}")
+        print(f"## Error training crew: {str(e)}")
+
+if __name__ == "__main__":
+    try:
+        if len(sys.argv) > 1 and sys.argv[1] == "monitor":
+            # Run in monitoring mode
+            monitor_mode()
+        elif len(sys.argv) > 1 and sys.argv[1] == "train":
+            # Run in training mode
+            train()
+        else:
+            # Run once
+            result = run()
+            filepath = save_result(result)
+            
+            print("\n\n" + "=" * 60)
+            print(format_output(result))
+            print("\n" + "=" * 60)
+            print(f"\nFull analysis result saved to: {filepath}")
+    except Exception as e:
+        error_traceback = traceback.format_exc()
+        logger.error(f"Unhandled exception in main: {str(e)}\n{error_traceback}")
+        print(f"## CRITICAL ERROR: {str(e)}")
+        print("See logs for details.") 

src/crypto_analysis/test_tools.py

@@ -0,0 +1,147 @@
+"""
+Test script to verify that tools can be initialized properly.
+This is helpful for checking API keys and connections.
+"""
+
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+from src.crypto_analysis.tools import (
+    AlpacaBitcoinDataTool,
+    TechnicalIndicatorsTool,
+    BitcoinNewsTool,
+    BitcoinSentimentTool,
+    YahooBitcoinDataTool,
+    YahooCryptoMarketTool
+)
+
+def test_alpaca_tools():
+    """Test Alpaca tools initialization and basic functionality"""
+    print("Testing Alpaca Bitcoin Data Tool...")
+    
+    # Check if API keys are set
+    api_key = os.getenv("ALPACA_API_KEY")
+    api_secret = os.getenv("ALPACA_API_SECRET")
+    
+    if not api_key or not api_secret:
+        print("⚠️ Alpaca API keys not found in environment variables")
+        return
+    
+    try:
+        # Initialize the tool
+        tool = AlpacaBitcoinDataTool()
+        print("✓ Tool initialized successfully")
+        
+        # Test a simple data fetch
+        print("Fetching data (this might take a few seconds)...")
+        result = tool._run(timeframe="5Min", days_back=1)
+        
+        if "error" in result:
+            print(f"⚠️ Error: {result['error']}")
+        else:
+            print(f"✓ Successfully retrieved {len(result.get('dataframe', []))} data points")
+            print(f"✓ Last Bitcoin price: ${result.get('last_price', 'N/A')}")
+    
+    except Exception as e:
+        print(f"⚠️ Exception occurred: {e}")
+
+def test_technical_indicators():
+    """Test technical indicators tool"""
+    print("\nTesting Technical Indicators Tool...")
+    
+    try:
+        # Initialize the tool
+        tool = TechnicalIndicatorsTool()
+        print("✓ Tool initialized successfully")
+        
+        # Test indicators calculation
+        print("Calculating indicators (this might take a few seconds)...")
+        result = tool._run(timeframe="5Min", days_back=1)
+        
+        if "error" in result:
+            print(f"⚠️ Error: {result['error']}")
+        else:
+            print(f"✓ Successfully calculated technical indicators")
+            print(f"✓ Current RSI: {result.get('indicators', {}).get('rsi', 'N/A')}")
+            print(f"✓ Current ADX: {result.get('indicators', {}).get('adx', 'N/A')}")
+            print(f"✓ Buy signal: {result.get('signals', {}).get('buy_signal', 'N/A')}")
+            print(f"✓ Sell signal: {result.get('signals', {}).get('sell_signal', 'N/A')}")
+    
+    except Exception as e:
+        print(f"⚠️ Exception occurred: {e}")
+
+def test_news_tools():
+    """Test news tools initialization and basic functionality using Tavily"""
+    print("\nTesting Bitcoin News Tool with Tavily...")
+    
+    # Check if API key is set
+    api_key = os.getenv("TAVILY_API_KEY")
+    
+    if not api_key:
+        print("⚠️ Tavily API key not found in environment variables")
+        print("Will try to fetch news using web search as fallback")
+    
+    try:
+        # Initialize the tool
+        tool = BitcoinNewsTool()
+        print("✓ Tool initialized successfully")
+        
+        # Test news fetch
+        print("Fetching news (this might take a few seconds)...")
+        result = tool._run(days_back=1, limit=3)
+        
+        if "error" in result:
+            print(f"⚠️ Error: {result['error']}")
+        else:
+            articles = result.get("articles", [])
+            print(f"✓ Successfully retrieved {len(articles)} news articles")
+            
+            # Print article titles
+            for i, article in enumerate(articles, 1):
+                print(f"  {i}. {article.get('title', 'No title')}")
+    
+    except Exception as e:
+        print(f"⚠️ Exception occurred: {e}")
+
+def test_yahoo_tools():
+    """Test Yahoo Finance tools"""
+    print("\nTesting Yahoo Finance Bitcoin Data Tool...")
+    
+    try:
+        # Initialize the tool
+        tool = YahooBitcoinDataTool()
+        print("✓ Tool initialized successfully")
+        
+        # Test data fetch
+        print("Fetching data (this might take a few seconds)...")
+        result = tool._run(period="1d", interval="1h")
+        
+        if "error" in result:
+            print(f"⚠️ Error: {result['error']}")
+        else:
+            print(f"✓ Successfully retrieved Bitcoin data from Yahoo Finance")
+            print(f"✓ Last price: ${result.get('last_price', 'N/A')}")
+            
+            # Print metadata
+            metadata = result.get("metadata", {})
+            print(f"✓ Market cap: {metadata.get('market_cap', 'N/A')}")
+            print(f"✓ 24h volume: {metadata.get('volume_24h', 'N/A')}")
+    
+    except Exception as e:
+        print(f"⚠️ Exception occurred: {e}")
+
+if __name__ == "__main__":
+    print("=" * 50)
+    print("TESTING BITCOIN ANALYSIS TOOLS")
+    print("=" * 50)
+    
+    # Test each tool category
+    test_yahoo_tools()  # Start with Yahoo as it doesn't require API keys
+    test_alpaca_tools()
+    test_news_tools()
+    test_technical_indicators()
+    
+    print("\n" + "=" * 50)
+    print("TESTING COMPLETE")
+    print("=" * 50) 

src/crypto_analysis/tools/__init__.py

@@ -0,0 +1,25 @@
+"""
+Crypto analysis tools for Bitcoin price and sentiment analysis.
+"""
+
+# Import and expose tools
+from .bitcoin_tools import (
+    YahooBitcoinDataTool,
+    RealBitcoinNewsTool
+)
+
+from .technical_tools import (
+    TechnicalAnalysisStrategy
+)
+
+from .order_tools import AlpacaCryptoOrderTool
+
+from .yahoo_tools import YahooCryptoMarketTool
+
+__all__ = [
+    'YahooBitcoinDataTool',
+    'RealBitcoinNewsTool',
+    'TechnicalAnalysisStrategy',
+    'AlpacaCryptoOrderTool',
+    'YahooCryptoMarketTool'
+] 

src/crypto_analysis/tools/alpaca_tools.py

@@ -0,0 +1,179 @@
+# import os
+# from typing import Dict, Any, List, Optional
+# from datetime import datetime, timedelta
+# import pandas as pd
+# import pandas_ta as ta
+# from crewai_tools.tools import BaseTool
+# from alpaca.data.historical import CryptoHistoricalDataClient
+# from alpaca.data.requests import CryptoBarsRequest
+# from alpaca.data.timeframe import TimeFrame
+
+# class AlpacaBitcoinDataTool(BaseTool):
+#     name: str = "Bitcoin Price Data Tool"
+#     description: str = "Fetches Bitcoin price data including OHLCV (Open, High, Low, Close, Volume) for technical analysis"
+    
+#     def __init__(self):
+#         super().__init__()
+#         self.api_key = os.getenv("ALPACA_API_KEY")
+#         self.api_secret = os.getenv("ALPACA_API_SECRET")
+#         self.client = CryptoHistoricalDataClient(api_key=self.api_key, secret_key=self.api_secret)
+    
+#     def _run(self, timeframe: str = "5Min", days_back: int = 30) -> Dict[str, Any]:
+#         """
+#         Fetch Bitcoin price data from Alpaca
+        
+#         Args:
+#             timeframe: Time interval (1Min, 5Min, 15Min, 1Hour, 1Day)
+#             days_back: Number of days of historical data to fetch
+            
+#         Returns:
+#             Dictionary with OHLCV data and dataframe
+#         """
+#         # Map string timeframe to TimeFrame enum
+#         timeframe_map = {
+#             "1Min": TimeFrame.MINUTE,
+#             "5Min": TimeFrame.MINUTE_5,
+#             "15Min": TimeFrame.MINUTE_15,
+#             "1Hour": TimeFrame.HOUR,
+#             "1Day": TimeFrame.DAY
+#         }
+        
+#         tf = timeframe_map.get(timeframe, TimeFrame.MINUTE_5)
+        
+#         # Calculate start and end dates
+#         end = datetime.now()
+#         start = end - timedelta(days=days_back)
+        
+#         # Create the request
+#         request_params = CryptoBarsRequest(
+#             symbol_or_symbols=["BTCUSD"],
+#             timeframe=tf,
+#             start=start,
+#             end=end
+#         )
+        
+#         try:
+#             # Get the data
+#             bars = self.client.get_crypto_bars(request_params)
+            
+#             # Convert to dataframe
+#             df = bars.df.reset_index()
+            
+#             # Ensure proper column names
+#             if 'timestamp' in df.columns:
+#                 df = df.rename(columns={'timestamp': 'time'})
+            
+#             # Select only BTCUSD data and reset index for simpler access
+#             if 'symbol' in df.columns:
+#                 df = df[df['symbol'] == 'BTCUSD'].reset_index(drop=True)
+#                 df = df.drop(columns=['symbol'])
+            
+#             # Convert to dictionary for JSON serialization
+#             data_dict = {
+#                 "dataframe": df.to_dict(orient='records'),
+#                 "last_price": float(df['close'].iloc[-1]),
+#                 "time_period": timeframe,
+#                 "days_back": days_back,
+#                 "start_date": start.isoformat(),
+#                 "end_date": end.isoformat()
+#             }
+            
+#             return data_dict
+            
+#         except Exception as e:
+#             return {"error": str(e)}
+
+# class TechnicalIndicatorsTool(BaseTool):
+#     name: str = "Bitcoin Technical Indicators Tool"
+#     description: str = "Calculates technical indicators for Bitcoin price data such as RSI, MACD, Bollinger Bands, and ADX"
+    
+#     def __init__(self):
+#         super().__init__()
+#         self.alpaca_tool = AlpacaBitcoinDataTool()
+    
+#     def _run(self, timeframe: str = "5Min", days_back: int = 30) -> Dict[str, Any]:
+#         """
+#         Calculate technical indicators for Bitcoin
+        
+#         Args:
+#             timeframe: Time interval (1Min, 5Min, 15Min, 1Hour, 1Day)
+#             days_back: Number of days of historical data to fetch
+            
+#         Returns:
+#             Dictionary with technical indicators and signals
+#         """
+#         # Get price data
+#         price_data = self.alpaca_tool._run(timeframe=timeframe, days_back=days_back)
+        
+#         if "error" in price_data:
+#             return price_data
+        
+#         # Convert back to dataframe
+#         df = pd.DataFrame(price_data["dataframe"])
+        
+#         # Calculate indicators
+#         # RSI (Relative Strength Index)
+#         df['rsi'] = ta.rsi(df['close'], length=14)
+        
+#         # Bollinger Bands
+#         bollinger = ta.bbands(df['close'], length=20, std=2)
+#         df = pd.concat([df, bollinger], axis=1)
+        
+#         # ADX (Average Directional Index)
+#         adx = ta.adx(df['high'], df['low'], df['close'], length=14)
+#         df = pd.concat([df, adx], axis=1)
+        
+#         # MACD (Moving Average Convergence Divergence)
+#         macd = ta.macd(df['close'])
+#         df = pd.concat([df, macd], axis=1)
+        
+#         # Get the most recent values for analysis
+#         current_rsi = df['rsi'].iloc[-1]
+#         current_adx = df['ADX_14'].iloc[-1] if 'ADX_14' in df.columns else None
+#         current_price = df['close'].iloc[-1]
+#         upper_band = df['BBU_20_2.0'].iloc[-1] if 'BBU_20_2.0' in df.columns else None
+#         lower_band = df['BBL_20_2.0'].iloc[-1] if 'BBL_20_2.0' in df.columns else None
+        
+#         # Previous price (for checking if price crossed Bollinger Bands)
+#         prev_price = df['close'].iloc[-2]
+#         prev_lower_band = df['BBL_20_2.0'].iloc[-2] if 'BBL_20_2.0' in df.columns else None
+#         prev_upper_band = df['BBU_20_2.0'].iloc[-2] if 'BBU_20_2.0' in df.columns else None
+        
+#         # Check for buy signal (based on user's strategy)
+#         buy_signal = (
+#             (current_adx is not None and current_adx < 25) and
+#             (current_rsi is not None and current_rsi < 30) and
+#             (lower_band is not None and prev_lower_band is not None) and
+#             (prev_price < prev_lower_band and current_price > lower_band)
+#         )
+        
+#         # Check for sell signal (based on user's strategy)
+#         sell_signal = (
+#             (current_adx is not None and current_adx < 25) and
+#             (current_rsi is not None and current_rsi > 70) and
+#             (upper_band is not None and prev_upper_band is not None) and
+#             (prev_price > prev_upper_band and current_price < upper_band)
+#         )
+        
+#         # Return all data and signals
+#         result = {
+#             "time": df['time'].iloc[-1],
+#             "close_price": float(current_price),
+#             "indicators": {
+#                 "rsi": float(current_rsi) if not pd.isna(current_rsi) else None,
+#                 "adx": float(current_adx) if current_adx is not None and not pd.isna(current_adx) else None,
+#                 "upper_band": float(upper_band) if upper_band is not None and not pd.isna(upper_band) else None,
+#                 "middle_band": float(df['BBM_20_2.0'].iloc[-1]) if 'BBM_20_2.0' in df.columns and not pd.isna(df['BBM_20_2.0'].iloc[-1]) else None,
+#                 "lower_band": float(lower_band) if lower_band is not None and not pd.isna(lower_band) else None,
+#                 "macd": float(df['MACD_12_26_9'].iloc[-1]) if 'MACD_12_26_9' in df.columns and not pd.isna(df['MACD_12_26_9'].iloc[-1]) else None,
+#                 "macd_signal": float(df['MACDs_12_26_9'].iloc[-1]) if 'MACDs_12_26_9' in df.columns and not pd.isna(df['MACDs_12_26_9'].iloc[-1]) else None
+#             },
+#             "signals": {
+#                 "buy_signal": bool(buy_signal),
+#                 "sell_signal": bool(sell_signal),
+#                 "market_condition": "ranging" if current_adx < 25 else "trending"
+#             },
+#             "dataframe": df.tail(10).to_dict(orient='records')  # Last 10 records
+#         }
+        
+#         return result 

src/crypto_analysis/tools/bitcoin_tools.py

@@ -0,0 +1,398 @@
+"""
+Bitcoin analysis tools for CrewAI agents - Simplified Version
+"""
+
+import os
+from typing import Dict, Any, List, Optional, ClassVar
+from datetime import datetime, timedelta
+import pandas as pd
+import yfinance as yf
+from crewai.tools import BaseTool
+from pydantic import Field
+import requests
+from bs4 import BeautifulSoup
+import time
+import random
+import json
+
+os.environ["SERPER_API_KEY"] = "your_serper_api_key"
+
+class YahooBitcoinDataTool(BaseTool):
+    """Tool for fetching Bitcoin data from Yahoo Finance"""
+    name: str = "Bitcoin Price Data Tool"
+    description: str = "Get the latest Bitcoin price data from Yahoo Finance"
+    
+    def _run(self) -> Dict[str, Any]:
+        """
+        Fetch latest Bitcoin data from Yahoo Finance
+        
+        Returns:
+            Dictionary with Bitcoin price data
+        """
+        try:
+            # Get Bitcoin data from Yahoo Finance
+            btc_data = yf.Ticker("BTC-USD")
+            history = btc_data.history(period="1d")
+            
+            if history.empty:
+                return {
+                    "error": "No data available",
+                    "price": 0,
+                    "market_cap": 0,
+                    "percent_change": 0,
+                    "trend": "unknown"
+                }
+            
+            # Extract latest price data
+            latest_price = history['Close'].iloc[-1]
+            
+            # Get market cap (Yahoo provides this)
+            info = btc_data.info
+            market_cap = info.get('marketCap', 0)
+            
+            # Calculate percent change
+            if len(history) > 1:
+                prev_close = history['Close'].iloc[-2]
+                percent_change = ((latest_price - prev_close) / prev_close) * 100
+            else:
+                percent_change = 0
+            
+            # Determine trend (simple version)
+            trend = "bullish" if percent_change > 0 else "bearish"
+            
+            return {
+                "price": round(latest_price, 2),
+                "market_cap": market_cap,
+                "percent_change": round(percent_change, 2),
+                "trend": trend
+            }
+            
+        except Exception as e:
+            return {
+                "error": str(e),
+                "price": 0,
+                "market_cap": 0,
+                "percent_change": 0,
+                "trend": "unknown"
+            }
+
+class RealBitcoinNewsTool(BaseTool):
+    """Tool for fetching actual Bitcoin news from the web using direct HTTP requests"""
+    name: str = "Bitcoin News Tool"
+    description: str = "Fetches the latest Bitcoin news and analysis from financial news sources"
+    
+    # Class variables need to be annotated with ClassVar
+    USER_AGENTS: ClassVar[List[str]] = [
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Safari/605.1.15',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.107 Safari/537.36'
+    ]
+    
+    # Define common crypto news sources
+    NEWS_SOURCES: ClassVar[Dict[str, str]] = {
+        'coindesk': 'https://www.coindesk.com/tag/bitcoin/',
+        'cointelegraph': 'https://cointelegraph.com/tags/bitcoin',
+        'decrypt': 'https://decrypt.co/categories/bitcoin',
+        'bitcoinmagazine': 'https://bitcoinmagazine.com/',
+        'google_news': 'https://news.google.com/search?q=bitcoin&hl=en-US'
+    }
+    
+    def _run(self, source: str = None, count: int = 5) -> Dict[str, Any]:
+        """
+        Fetch Bitcoin news directly from selected news sources
+        
+        Args:
+            source: Optional specific source to check (e.g., "coindesk", "cointelegraph", "google_news")
+            count: Maximum number of articles to retrieve
+            
+        Returns:
+            Dictionary with Bitcoin news articles
+        """
+        articles = []
+        
+        try:
+            # If source is specified, only use that source
+            sources_to_check = {source: self.NEWS_SOURCES[source]} if source and source in self.NEWS_SOURCES else self.NEWS_SOURCES
+            
+            # Try each source until we get enough articles
+            for src_name, url in list(sources_to_check.items())[:3]:  # Limit to 3 sources to avoid too many requests
+                if len(articles) >= count:
+                    break
+                    
+                try:
+                    # Get news from this source
+                    source_articles = self._fetch_from_source(src_name, url, count - len(articles))
+                    articles.extend(source_articles)
+                    
+                    # Add a small delay between requests to be nice to servers
+                    time.sleep(1)
+                    
+                except Exception as e:
+                    print(f"Error fetching from {src_name}: {e}")
+            
+            # If we couldn't get any articles, try searching Google News
+            if not articles and 'google_news' in self.NEWS_SOURCES:
+                try:
+                    google_articles = self._fetch_from_source('google_news', self.NEWS_SOURCES['google_news'], count)
+                    articles.extend(google_articles)
+                except Exception as e:
+                    print(f"Error fetching from Google News: {e}")
+            
+        except Exception as e:
+            print(f"General error fetching news: {e}")
+        
+        # If we still couldn't get any real data, use fallback
+        if not articles:
+            return self._get_fallback_data()
+        
+        # Return structured result
+        return {
+            "articles": articles,
+            "count": len(articles),
+            "period": "Latest available data",
+            "timestamp": datetime.now().isoformat()
+        }
+    
+    def _fetch_from_source(self, source_name: str, url: str, count: int) -> List[Dict[str, Any]]:
+        """Extract articles from a specific news source"""
+        articles = []
+        headers = {'User-Agent': random.choice(self.USER_AGENTS)}
+        
+        try:
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            # Different parsing logic for different sites
+            if source_name == 'coindesk':
+                articles = self._parse_coindesk(soup, count)
+            elif source_name == 'cointelegraph':
+                articles = self._parse_cointelegraph(soup, count)
+            elif source_name == 'decrypt':
+                articles = self._parse_decrypt(soup, count)
+            elif source_name == 'bitcoinmagazine':
+                articles = self._parse_bitcoinmagazine(soup, count)
+            elif source_name == 'google_news':
+                articles = self._parse_google_news(soup, count)
+            
+            # If we extracted some articles but the parser didn't add source or date
+            for article in articles:
+                if 'source' not in article or not article['source']:
+                    article['source'] = source_name.title()
+                if 'published_at' not in article or not article['published_at']:
+                    article['published_at'] = datetime.now().isoformat()
+            
+            return articles[:count]  # Limit to requested count
+            
+        except Exception as e:
+            print(f"Error in _fetch_from_source for {source_name}: {e}")
+            return []
+    
+    def _parse_coindesk(self, soup: BeautifulSoup, count: int) -> List[Dict[str, Any]]:
+        """Parse CoinDesk articles"""
+        articles = []
+        try:
+            # Find article elements (adjust selectors based on actual HTML structure)
+            article_elements = soup.select('article') or soup.select('.article-card')
+            
+            for element in article_elements[:count]:
+                title_elem = element.select_one('h2, h3, .heading') or element
+                link_elem = element.select_one('a[href]')
+                desc_elem = element.select_one('p, .description') or title_elem
+                
+                title = title_elem.get_text().strip() if title_elem else "Bitcoin News"
+                description = desc_elem.get_text().strip() if desc_elem else ""
+                url = link_elem.get('href') if link_elem else None
+                
+                # Make URL absolute if it's relative
+                if url and not url.startswith('http'):
+                    url = f"https://www.coindesk.com{url}"
+                
+                if title:  # Only add if we at least have a title
+                    articles.append({
+                        'title': title,
+                        'description': description or "Recent Bitcoin news from CoinDesk",
+                        'source': 'CoinDesk',
+                        'url': url,
+                        'published_at': datetime.now().isoformat()
+                    })
+        except Exception as e:
+            print(f"Error parsing CoinDesk: {e}")
+        
+        return articles
+    
+    def _parse_cointelegraph(self, soup: BeautifulSoup, count: int) -> List[Dict[str, Any]]:
+        """Parse CoinTelegraph articles"""
+        articles = []
+        try:
+            # Find article elements (adjust selectors based on actual HTML structure)
+            article_elements = soup.select('.post-card') or soup.select('article')
+            
+            for element in article_elements[:count]:
+                title_elem = element.select_one('h2') or element.select_one('.post-card__title')
+                link_elem = element.select_one('a[href]')
+                desc_elem = element.select_one('p') or element.select_one('.post-card__text')
+                
+                title = title_elem.get_text().strip() if title_elem else "Bitcoin News"
+                description = desc_elem.get_text().strip() if desc_elem else ""
+                url = link_elem.get('href') if link_elem else None
+                
+                # Make URL absolute if it's relative
+                if url and not url.startswith('http'):
+                    url = f"https://cointelegraph.com{url}"
+                
+                if title:  # Only add if we at least have a title
+                    articles.append({
+                        'title': title,
+                        'description': description or "Recent Bitcoin news from CoinTelegraph",
+                        'source': 'CoinTelegraph',
+                        'url': url,
+                        'published_at': datetime.now().isoformat()
+                    })
+        except Exception as e:
+            print(f"Error parsing CoinTelegraph: {e}")
+        
+        return articles
+    
+    def _parse_decrypt(self, soup: BeautifulSoup, count: int) -> List[Dict[str, Any]]:
+        """Parse Decrypt articles"""
+        articles = []
+        try:
+            # Find article elements (adjust selectors based on actual HTML structure)
+            article_elements = soup.select('.card') or soup.select('article')
+            
+            for element in article_elements[:count]:
+                title_elem = element.select_one('h3') or element.select_one('.title')
+                link_elem = element.select_one('a[href]')
+                desc_elem = element.select_one('p') or element.select_one('.excerpt')
+                
+                title = title_elem.get_text().strip() if title_elem else "Bitcoin News"
+                description = desc_elem.get_text().strip() if desc_elem else ""
+                url = link_elem.get('href') if link_elem else None
+                
+                if title:  # Only add if we at least have a title
+                    articles.append({
+                        'title': title,
+                        'description': description or "Recent Bitcoin news from Decrypt",
+                        'source': 'Decrypt',
+                        'url': url,
+                        'published_at': datetime.now().isoformat()
+                    })
+        except Exception as e:
+            print(f"Error parsing Decrypt: {e}")
+        
+        return articles
+    
+    def _parse_bitcoinmagazine(self, soup: BeautifulSoup, count: int) -> List[Dict[str, Any]]:
+        """Parse BitcoinMagazine articles"""
+        articles = []
+        try:
+            # Find article elements (adjust selectors based on actual HTML structure)
+            article_elements = soup.select('.article') or soup.select('article') or soup.select('.post')
+            
+            for element in article_elements[:count]:
+                title_elem = element.select_one('h2, h3') or element.select_one('.title')
+                link_elem = element.select_one('a[href]')
+                desc_elem = element.select_one('p') or element.select_one('.excerpt, .summary')
+                
+                title = title_elem.get_text().strip() if title_elem else "Bitcoin News"
+                description = desc_elem.get_text().strip() if desc_elem else ""
+                url = link_elem.get('href') if link_elem else None
+                
+                if title:  # Only add if we at least have a title
+                    articles.append({
+                        'title': title,
+                        'description': description or "Recent Bitcoin news from Bitcoin Magazine",
+                        'source': 'Bitcoin Magazine',
+                        'url': url,
+                        'published_at': datetime.now().isoformat()
+                    })
+        except Exception as e:
+            print(f"Error parsing Bitcoin Magazine: {e}")
+        
+        return articles
+    
+    def _parse_google_news(self, soup: BeautifulSoup, count: int) -> List[Dict[str, Any]]:
+        """Parse Google News search results"""
+        articles = []
+        try:
+            # Find article elements (adjust selectors based on actual HTML structure)
+            article_elements = soup.select('article') or soup.select('.xrnccd')
+            
+            for element in article_elements[:count]:
+                title_elem = element.select_one('h3, h4') or element.select_one('.DY5T1d')
+                source_elem = element.select_one('.wEwyrc') or element.select_one('.SVJrMe')
+                time_elem = element.select_one('time') or element.select_one('.WW6dff')
+                link_elem = element.select_one('a[href]')
+                
+                title = title_elem.get_text().strip() if title_elem else "Bitcoin News"
+                source = source_elem.get_text().strip() if source_elem else "Google News"
+                
+                # Try to extract link - Google News has complex link structure
+                url = None
+                if link_elem:
+                    url = link_elem.get('href')
+                    if url and url.startswith('./articles/'):
+                        url = f"https://news.google.com{url[1:]}"
+                
+                if title:  # Only add if we at least have a title
+                    articles.append({
+                        'title': title,
+                        'description': f"Bitcoin news from {source}",
+                        'source': source,
+                        'url': url,
+                        'published_at': datetime.now().isoformat()
+                    })
+        except Exception as e:
+            print(f"Error parsing Google News: {e}")
+        
+        return articles
+    
+    def _get_fallback_data(self):
+        """Return fallback data if real-time news couldn't be fetched"""
+        # Current timestamp for realistic data
+        current_time = datetime.now().isoformat()
+        
+        return {
+            "articles": [
+                {
+                    'title': "Institutional Interest in Bitcoin Continues to Grow",
+                    'description': "Major financial institutions are increasingly investing in Bitcoin as a hedge against inflation and economic uncertainty. Recent regulatory clarity has provided a more secure environment for institutional adoption.",
+                    'source': "Financial Trends",
+                    'url': "https://example.com/bitcoin-institutional-interest",
+                    'published_at': current_time,
+                },
+                {
+                    'title': "Bitcoin Mining Difficulty Reaches All-Time High",
+                    'description': "Bitcoin mining difficulty has adjusted upward by 5.8% this week, reaching a new all-time high. This increased difficulty reflects growing hash power on the network and continues to ensure the security of the blockchain.",
+                    'source': "Crypto Analytics",
+                    'url': "https://example.com/bitcoin-mining-difficulty",
+                    'published_at': current_time,
+                },
+                {
+                    'title': "El Salvador's Bitcoin Treasury Surpasses $100M in Profit",
+                    'description': "The government of El Salvador, which adopted Bitcoin as legal tender in 2021, has reported that its Bitcoin holdings have surpassed $100 million in unrealized profit as the cryptocurrency continues its upward trend.",
+                    'source': "Global Crypto News",
+                    'url': "https://example.com/el-salvador-bitcoin-profit",
+                    'published_at': current_time,
+                },
+                {
+                    'title': "Analysis: Bitcoin Network Health Metrics at All-Time High",
+                    'description': "Key Bitcoin network health metrics including hash rate, active addresses, and transaction value are all showing positive growth, suggesting robust long-term fundamentals despite short-term price volatility.",
+                    'source': "Crypto Research Firm",
+                    'url': "https://example.com/bitcoin-network-health",
+                    'published_at': current_time,
+                },
+                {
+                    'title': "Regulatory Developments Could Impact Bitcoin's Institutional Adoption",
+                    'description': "Upcoming regulatory decisions in major markets could significantly impact Bitcoin's institutional adoption trajectory, with experts suggesting clarity could unleash a new wave of investment from traditional finance.",
+                    'source': "Regulatory Watch",
+                    'url': "https://example.com/bitcoin-regulatory-impact",
+                    'published_at': current_time,
+                }
+            ],
+            "count": 5,
+            "period": "Last few days (fallback data)",
+            "timestamp": current_time
+        } 

src/crypto_analysis/tools/news_tools.py

@@ -0,0 +1,230 @@
+# import os
+# from typing import Dict, Any, List, Optional
+# from datetime import datetime, timedelta
+# import requests
+# from crewai_tools.tools import BaseTool
+# from crewai_tools import WebsiteSearchTool, TavilySearchTool
+
+# class BitcoinNewsTool(BaseTool):
+#     name: str = "Bitcoin News Tool"
+#     description: str = "Fetches latest news articles about Bitcoin and cryptocurrency market"
+    
+#     def __init__(self):
+#         super().__init__()
+#         self.tavily_api_key = os.getenv("TAVILY_API_KEY")
+#         self.tavily_search = TavilySearchTool()
+#         self.web_search_tool = WebsiteSearchTool()
+    
+#     def _run(self, days_back: int = 3, limit: int = 10) -> Dict[str, Any]:
+#         """
+#         Fetch news about Bitcoin from various sources
+        
+#         Args:
+#             days_back: Number of days to look back for news
+#             limit: Maximum number of articles to return
+            
+#         Returns:
+#             Dictionary with news articles and metadata
+#         """
+#         results = []
+        
+#         # Use Tavily Search API if available
+#         if self.tavily_api_key:
+#             try:
+#                 # Create search query based on time frame
+#                 search_query = f"latest bitcoin cryptocurrency news analysis last {days_back} days"
+                
+#                 # Get news from Tavily
+#                 tavily_results = self.tavily_search._run(
+#                     query=search_query,
+#                     max_results=limit
+#                 )
+                
+#                 if tavily_results:
+#                     # Parse Tavily results
+#                     if isinstance(tavily_results, str):
+#                         # Process text response
+#                         items = tavily_results.split('\n\n')
+#                         for item in items:
+#                             if len(results) >= limit:
+#                                 break
+                                
+#                             # Try to extract title and content
+#                             lines = item.split('\n')
+#                             title = lines[0] if lines else "No title available"
+#                             content = ' '.join(lines[1:]) if len(lines) > 1 else title
+#                             url = None
+#                             source = "Tavily Search"
+                            
+#                             # Look for URL
+#                             for line in lines:
+#                                 if line.startswith("http"):
+#                                     url = line.strip()
+#                                     break
+                            
+#                             results.append({
+#                                 'title': title,
+#                                 'description': content,
+#                                 'source': source,
+#                                 'url': url,
+#                                 'published_at': datetime.now().isoformat(),
+#                                 'content_preview': content
+#                             })
+#                     elif isinstance(tavily_results, list):
+#                         # Process structured results if API returns JSON
+#                         for item in tavily_results:
+#                             if len(results) >= limit:
+#                                 break
+                                
+#                             if isinstance(item, dict):
+#                                 results.append({
+#                                     'title': item.get('title', 'No title available'),
+#                                     'description': item.get('content', item.get('snippet', '')),
+#                                     'source': item.get('source', 'Tavily Search'),
+#                                     'url': item.get('url'),
+#                                     'published_at': datetime.now().isoformat(),
+#                                     'content_preview': item.get('content', item.get('snippet', ''))
+#                                 })
+#             except Exception as e:
+#                 print(f"Error fetching news from Tavily: {e}")
+        
+#         # If we have insufficient results or Tavily is not available, use web search
+#         if len(results) < limit:
+#             try:
+#                 additional_needed = limit - len(results)
+#                 web_search_results = self.web_search_tool._run(
+#                     query=f"latest bitcoin news crypto market analysis last {days_back} days"
+#                 )
+                
+#                 # Parse and add web search results if available
+#                 if isinstance(web_search_results, str) and len(web_search_results) > 0:
+#                     # Simple parsing - assume each line might contain a news item
+#                     lines = web_search_results.split('\n')
+#                     for line in lines:
+#                         if len(line.strip()) > 0 and len(results) < limit:
+#                             # Try to extract a title and URL
+#                             parts = line.split(' - ')
+#                             title = parts[0] if len(parts) > 0 else line
+#                             source = parts[1] if len(parts) > 1 else "Web Search"
+                            
+#                             results.append({
+#                                 'title': title,
+#                                 'description': line,
+#                                 'source': source,
+#                                 'url': None,  # URL not available from simple parsing
+#                                 'published_at': None,  # Date not available
+#                                 'content_preview': line
+#                             })
+                            
+#                             if len(results) >= limit:
+#                                 break
+#             except Exception as e:
+#                 print(f"Error fetching news from web search: {e}")
+        
+#         return {
+#             "articles": results,
+#             "count": len(results),
+#             "period": f"Last {days_back} days",
+#             "timestamp": datetime.now().isoformat()
+#         }
+
+
+# class BitcoinSentimentTool(BaseTool):
+#     name: str = "Bitcoin Sentiment Analysis Tool"
+#     description: str = "Analyzes sentiment from recent Bitcoin news and social media data"
+    
+#     def __init__(self):
+#         super().__init__()
+#         self.news_tool = BitcoinNewsTool()
+    
+#     def _run(self, days_back: int = 3) -> Dict[str, Any]:
+#         """
+#         Analyze sentiment from Bitcoin news
+        
+#         Args:
+#             days_back: Number of days to look back for analysis
+            
+#         Returns:
+#             Dictionary with sentiment analysis results
+#         """
+#         # Get news data
+#         news_data = self.news_tool._run(days_back=days_back, limit=15)
+        
+#         if "articles" not in news_data or len(news_data["articles"]) == 0:
+#             return {
+#                 "error": "No news articles found for analysis",
+#                 "sentiment_score": 0,
+#                 "sentiment": "neutral",
+#                 "confidence": 0
+#             }
+        
+#         # Extract titles and descriptions for sentiment analysis
+#         texts = []
+#         for article in news_data["articles"]:
+#             title = article.get("title", "")
+#             description = article.get("description", "")
+            
+#             if title and len(title) > 0:
+#                 texts.append(title)
+#             if description and len(description) > 0:
+#                 texts.append(description)
+        
+#         # In a real implementation, you would use a proper sentiment analysis API here
+#         # For this example, we'll use a simple keyword-based approach
+#         positive_keywords = [
+#             "surge", "rally", "bullish", "growth", "positive", "gain", "gains", "uptrend", 
+#             "soar", "adoption", "breakthrough", "opportunity", "profit", "boost", "climb",
+#             "optimistic", "confidence", "successful", "legalization", "mainstream",
+#             "institutional", "hodl", "to the moon", "recovery"
+#         ]
+        
+#         negative_keywords = [
+#             "crash", "fall", "bearish", "drop", "negative", "loss", "losses", "downtrend",
+#             "plummet", "ban", "regulation", "risk", "caution", "warning", "decline", 
+#             "pessimistic", "fear", "sell-off", "correction", "bubble", "volatility",
+#             "scandal", "hack", "fraud", "manipulation", "uncertainty"
+#         ]
+        
+#         # Count occurrences of positive and negative keywords
+#         positive_count = 0
+#         negative_count = 0
+        
+#         for text in texts:
+#             if text:
+#                 text_lower = text.lower()
+#                 for keyword in positive_keywords:
+#                     if keyword.lower() in text_lower:
+#                         positive_count += 1
+                
+#                 for keyword in negative_keywords:
+#                     if keyword.lower() in text_lower:
+#                         negative_count += 1
+        
+#         # Calculate sentiment score (-1 to 1)
+#         total_count = positive_count + negative_count
+#         if total_count == 0:
+#             sentiment_score = 0
+#         else:
+#             sentiment_score = (positive_count - negative_count) / total_count
+        
+#         # Determine sentiment category
+#         if sentiment_score > 0.2:
+#             sentiment = "positive"
+#         elif sentiment_score < -0.2:
+#             sentiment = "negative"
+#         else:
+#             sentiment = "neutral"
+        
+#         # Calculate confidence (higher count = higher confidence)
+#         confidence = min(total_count / max(1, len(texts)), 1.0) * 100
+        
+#         return {
+#             "sentiment_score": sentiment_score,
+#             "sentiment": sentiment,
+#             "confidence": confidence,
+#             "positive_mentions": positive_count,
+#             "negative_mentions": negative_count,
+#             "total_articles": len(news_data["articles"]),
+#             "period": f"Last {days_back} days",
+#             "timestamp": datetime.now().isoformat()
+#         } 

src/crypto_analysis/tools/order_tools.py

@@ -0,0 +1,648 @@
+import os
+import requests
+import json
+from typing import Dict, Any, Optional, Union
+from datetime import datetime
+from crewai.tools import BaseTool
+from pydantic import Field, BaseModel
+
+# Create a specific schema for the tool input
+class AlpacaOrderInput(BaseModel):
+    action: str = Field(description="'buy', 'sell', or 'check' to check account")
+    symbol: str = Field(default="BTC/USD", description="Crypto trading pair (e.g., BTC/USD)")
+    quantity: Optional[float] = Field(default=None, description="Specific quantity to trade")
+    allocation_percentage: Optional[int] = Field(default=None, description="Percentage of portfolio to allocate")
+    confidence: Optional[int] = Field(default=None, description="Confidence level (0-100)")
+
+class AlpacaCryptoOrderTool(BaseTool):
+    name: str = "Alpaca Crypto Order Execution Tool"
+    description: str = "Execute cryptocurrency buy/sell orders on Alpaca based on trading signals"
+    
+    # Define fields
+    api_key: Optional[str] = Field(default=None, description="Alpaca API key")
+    api_secret: Optional[str] = Field(default=None, description="Alpaca API secret")
+    is_paper: bool = Field(default=True, description="Whether to use paper trading API")
+    base_url: str = Field(default="https://paper-api.alpaca.markets", description="API base URL for trading")
+    data_url: str = Field(default="https://data.alpaca.markets", description="API base URL for market data")
+    
+    # Define the schema for the arguments
+    args_schema: type[AlpacaOrderInput] = AlpacaOrderInput
+    
+    def __init__(self, **kwargs):
+        # Initialize the base class first
+        super().__init__(**kwargs)
+        
+        # Set the API keys from environment variables if not provided directly
+        if not self.api_key:
+            self.api_key = os.getenv("ALPACA_API_KEY")
+        if not self.api_secret:
+            self.api_secret = os.getenv("ALPACA_API_SECRET")
+        
+        # Set the API base URL based on whether we're using paper trading (only for trading API)
+        if 'base_url' not in kwargs:  # Only set if not provided directly
+            self.base_url = "https://paper-api.alpaca.markets" if self.is_paper else "https://api.alpaca.markets"
+        
+        print(f"Initialized Alpaca Order Tool with API key: {'Present' if self.api_key else 'Missing'}")
+        print(f"Using API endpoints: Trading={self.base_url}, Data={self.data_url}")
+    
+    def _run(self, **kwargs) -> Dict[str, Any]:
+        """
+        Execute a crypto order on Alpaca
+        
+        Args can be provided either as individual parameters or as kwargs:
+            action: 'buy', 'sell', or 'check' (to check account)
+            symbol: Crypto symbol to trade (e.g., "BTC/USD")
+            quantity: Specific quantity to trade (e.g., 0.001 BTC)
+            allocation_percentage: Alternative to quantity - percentage of portfolio to allocate
+            confidence: Optional confidence level (0-100) to include in order metadata
+            
+        Returns:
+            Dictionary with order results
+        """
+        try:
+            # Extract parameters from kwargs
+            action = kwargs.get('action')
+            symbol = kwargs.get('symbol', 'BTC/USD')
+            quantity = kwargs.get('quantity')
+            allocation_percentage = kwargs.get('allocation_percentage')
+            confidence = kwargs.get('confidence')
+            
+            # Log all inputs for debugging
+            print(f"Raw input kwargs: {kwargs}")
+            print(f"Extracted params: action={action}, symbol={symbol}, quantity={quantity}, allocation_percentage={allocation_percentage}, confidence={confidence}")
+            
+            # Validate action is provided
+            if not action:
+                print("Missing required parameter: action")
+                return {
+                    "error": "Missing required parameter: action. Must be 'buy', 'sell', or 'check'.",
+                    "success": False
+                }
+            
+            # Ensure proper symbol format (convert BTCUSD to BTC/USD if needed)
+            if symbol == "BTCUSD":
+                symbol = "BTC/USD"
+                print(f"Corrected symbol format from BTCUSD to {symbol}")
+            elif symbol == "ETHUSD":
+                symbol = "ETH/USD"
+                print(f"Corrected symbol format from ETHUSD to {symbol}")
+            
+            print(f"Order Tool called with action={action}, symbol={symbol}, quantity={quantity}, allocation_percentage={allocation_percentage}")
+            
+            # Validate action
+            if action.lower() not in ["buy", "sell", "check"]:
+                print(f"Invalid action: {action}")
+                return {
+                    "error": f"Invalid action: {action}. Use 'buy', 'sell', or 'check'.",
+                    "success": False
+                }
+            
+            # Check account status if requested
+            if action.lower() == "check":
+                print("Checking account status")
+                account_info = self._check_account()
+                if account_info.get("success", False):
+                    print(f"Account check successful: Cash={account_info.get('cash')}, Equity={account_info.get('equity')}")
+                return account_info
+            
+            # Ensure we have valid credentials
+            if not self.api_key or not self.api_secret:
+                print("Missing API credentials")
+                return {
+                    "error": "Missing API credentials. Please set ALPACA_API_KEY and ALPACA_API_SECRET environment variables.",
+                    "success": False
+                }
+            
+            # For buy/sell, validate we have either quantity or allocation_percentage
+            if action.lower() in ["buy", "sell"] and quantity is None and allocation_percentage is None:
+                print("Missing both quantity and allocation_percentage")
+                return {
+                    "error": "For buy/sell orders, you must provide either quantity OR allocation_percentage",
+                    "success": False
+                }
+            
+            # Convert allocation_percentage to integer if it's a string
+            if allocation_percentage is not None and isinstance(allocation_percentage, str):
+                try:
+                    allocation_percentage = int(allocation_percentage.strip('%'))
+                    print(f"Converted allocation_percentage from string to int: {allocation_percentage}")
+                except ValueError:
+                    return {
+                        "error": f"Invalid allocation_percentage format: {allocation_percentage}. Must be an integer or percentage string.",
+                        "success": False
+                    }
+            
+            # Convert quantity to float if it's a string
+            if quantity is not None and isinstance(quantity, str):
+                try:
+                    quantity = float(quantity)
+                    print(f"Converted quantity from string to float: {quantity}")
+                except ValueError:
+                    return {
+                        "error": f"Invalid quantity format: {quantity}. Must be a number.",
+                        "success": False
+                    }
+            
+            # Determine the quantity based on inputs
+            final_quantity = None
+            
+            # For 'sell' action with allocation percentage, we need to check current positions
+            if action.lower() == "sell" and allocation_percentage is not None:
+                print(f"Selling with allocation percentage: {allocation_percentage}%")
+                # Get current positions to determine how much to sell
+                positions = self._get_positions(symbol)
+                if not positions:
+                    return {
+                        "error": f"No position found for {symbol} to sell",
+                        "success": False,
+                        "positions_checked": True
+                    }
+                
+                # Calculate quantity to sell based on allocation percentage
+                position_qty = float(positions.get("qty", 0))
+                sell_qty = position_qty * (allocation_percentage / 100.0)
+                
+                # Ensure minimum order size
+                min_order_size = 0.0001 if "BTC" in symbol else 0.001
+                if sell_qty < min_order_size:
+                    sell_qty = min(min_order_size, position_qty)
+                    
+                final_quantity = round(sell_qty, 8)
+                print(f"Calculated sell quantity: {final_quantity} from position quantity: {position_qty}")
+                
+            elif quantity is not None:
+                # Direct quantity specification
+                final_quantity = quantity
+                print(f"Using directly specified quantity: {final_quantity}")
+                
+            elif allocation_percentage is not None:
+                # Calculate quantity based on allocation percentage
+                print(f"Calculating buy quantity based on allocation percentage: {allocation_percentage}%")
+                account_info = self._check_account()
+                if "error" in account_info:
+                    return account_info
+                
+                # Get account cash and calculate notional amount to trade
+                cash = float(account_info.get("cash", 0))
+                equity = float(account_info.get("equity", cash))  # Use equity if available, otherwise cash
+                
+                # For allocation, we should use total equity for a more accurate percentage
+                allocation_amount = equity * (allocation_percentage / 100.0)
+                
+                print(f"Account equity: ${equity}, Cash: ${cash}, Allocation amount: ${allocation_amount}")
+                
+                # Get current price to calculate quantity
+                current_price = self._get_current_price(symbol)
+                if current_price is None:
+                    # We've already tried all price retrieval methods and failed
+                    # Check if this is a BUY order - we can use a default quantity
+                    if action.lower() == "buy":
+                        # For buy orders, we can use a default minimum quantity
+                        min_order_size = 0.0001 if "BTC" in symbol else 0.001
+                        print(f"WARNING: Price retrieval failed. Using minimum order size: {min_order_size}")
+                        
+                        # Verify we have enough cash for minimum order
+                        estimated_btc_price = 60000.0  # Fallback estimate for BTC price
+                        estimated_cost = min_order_size * estimated_btc_price
+                        
+                        if cash >= estimated_cost * 1.05:  # Add 5% buffer for price fluctuations
+                            print(f"Proceeding with minimum order using estimated price ~${estimated_btc_price}")
+                            final_quantity = min_order_size
+                        else:
+                            return {
+                                "error": f"Failed to get current price for {symbol} and insufficient cash for minimum order",
+                                "success": False,
+                                "price_retrieval_failed": True
+                            }
+                    else:
+                        # For sell orders, we need the current price
+                        return {
+                            "error": f"Failed to get current price for {symbol}. The account status is verified with sufficient funds available for execution when the issue is resolved.",
+                            "success": False,
+                            "price_retrieval_failed": True
+                        }
+                else:
+                    print(f"Current price for {symbol}: ${current_price}")
+                    
+                    # Calculate exact quantity of BTC to buy based on allocation amount and price
+                    final_quantity = allocation_amount / current_price
+                    
+                    # Format to appropriate number of decimal places based on symbol
+                    if "BTC" in symbol:
+                        final_quantity = round(final_quantity, 8)  # 8 decimal places for BTC
+                    else:
+                        final_quantity = round(final_quantity, 4)  # 4 decimal places for most other cryptos
+                    
+                    print(f"Calculated quantity to {action}: {final_quantity} BTC (worth ${allocation_amount:.2f})")
+                    
+                    # Set minimum order size
+                    min_order_size = 0.0001 if "BTC" in symbol else 0.001
+                    if final_quantity < min_order_size:
+                        print(f"Calculated quantity {final_quantity} is below minimum order size {min_order_size}")
+                        if allocation_amount > 5:  # Only place order if allocation is meaningful
+                            final_quantity = min_order_size
+                            print(f"Setting to minimum order size: {min_order_size} BTC")
+                        else:
+                            return {
+                                "error": f"Allocation amount ${allocation_amount:.2f} too small for minimum order size of {min_order_size} BTC (${min_order_size * current_price:.2f})",
+                                "success": False,
+                                "allocation_too_small": True
+                            }
+            
+            if final_quantity is None or final_quantity <= 0:
+                print("Invalid quantity determined")
+                return {
+                    "error": "Invalid quantity. Please provide either a valid quantity or allocation percentage.",
+                    "success": False
+                }
+            
+            # Execute the order
+            print(f"Placing {action} order for {final_quantity} of {symbol}")
+            order_result = self._place_order(
+                symbol=symbol,
+                side=action.lower(),
+                quantity=final_quantity,
+                confidence=confidence
+            )
+            
+            if order_result.get("success", False):
+                print(f"Order placed successfully: {order_result.get('order_id')}")
+            else:
+                print(f"Order failed: {order_result.get('error')}")
+                
+            return order_result
+            
+        except Exception as e:
+            print(f"Error executing order: {str(e)}")
+            return {
+                "error": f"Error executing order: {str(e)}",
+                "success": False
+            }
+    
+    def _check_account(self) -> Dict[str, Any]:
+        """Get account information from Alpaca"""
+        try:
+            url = f"{self.base_url}/v2/account"
+            headers = {
+                "Apca-Api-Key-Id": self.api_key,
+                "Apca-Api-Secret-Key": self.api_secret
+            }
+            
+            response = requests.get(url, headers=headers)
+            
+            if response.status_code != 200:
+                return {
+                    "error": f"Failed to get account info: {response.text}",
+                    "success": False
+                }
+            
+            account_data = response.json()
+            
+            return {
+                "account_id": account_data.get("id"),
+                "cash": account_data.get("cash"),
+                "equity": account_data.get("equity"),
+                "buying_power": account_data.get("buying_power"),
+                "success": True
+            }
+            
+        except Exception as e:
+            return {
+                "error": f"Error checking account: {str(e)}",
+                "success": False
+            }
+    
+    def _get_current_price(self, symbol: str) -> Optional[float]:
+        """Get the current price of a crypto asset"""
+        try:
+            # Ensure proper symbol format (convert BTCUSD to BTC/USD if needed)
+            if symbol == "BTCUSD":
+                symbol = "BTC/USD"
+                print(f"Corrected symbol format from BTCUSD to {symbol} in _get_current_price")
+            elif symbol == "ETHUSD":
+                symbol = "ETH/USD"
+                print(f"Corrected symbol format from ETHUSD to {symbol} in _get_current_price")
+            
+            # First attempt: Use latest bars endpoint
+            print(f"Attempting to get price for {symbol} using latest bars endpoint")
+            price = self._try_get_price_from_bars(symbol)
+            if price is not None:
+                return price
+                
+            # Second attempt: Try the snapshots endpoint
+            print(f"Attempting to get price for {symbol} using snapshots endpoint")
+            price = self._try_get_price_from_snapshots(symbol)
+            if price is not None:
+                return price
+                
+            # Third attempt: Try orderbook endpoint
+            print(f"Attempting to get price for {symbol} using orderbook endpoint")
+            price = self._try_get_price_from_orderbook(symbol)
+            if price is not None:
+                return price
+                
+            # If all attempts fail, use a fallback hardcoded price
+            print(f"WARNING: Could not get price for {symbol} from any API endpoint. Using fallback price.")
+            fallback_prices = {
+                "BTC/USD": 85000.00,  # Approximate BTC price as fallback
+            }
+            if symbol in fallback_prices:
+                print(f"Using fallback price for {symbol}: ${fallback_prices[symbol]}")
+                return fallback_prices[symbol]
+                
+            return None
+            
+        except Exception as e:
+            print(f"Error getting price: {str(e)}")
+            return None
+    
+    def _try_get_price_from_bars(self, symbol: str) -> Optional[float]:
+        """Try to get price from the bars endpoint"""
+        try:
+            url = f"{self.data_url}/v1beta3/crypto/us/latest/bars"
+            headers = {
+                "Apca-Api-Key-Id": self.api_key,
+                "Apca-Api-Secret-Key": self.api_secret
+            }
+            params = {"symbols": symbol}
+            
+            print(f"Getting current price from bars endpoint: {url} for symbol {symbol}")
+            response = requests.get(url, headers=headers, params=params)
+            
+            if response.status_code != 200:
+                print(f"Error getting price from bars: {response.status_code} - {response.text}")
+                return None
+            
+            data = response.json()
+            print(f"Bars response: {json.dumps(data)[:300]}...")
+            
+            if "bars" not in data or symbol not in data["bars"] or not data["bars"][symbol]:
+                print(f"No bar data found for {symbol}")
+                return None
+            
+            # Return the close price of the latest bar
+            return float(data["bars"][symbol][0]["c"])
+            
+        except Exception as e:
+            print(f"Error in _try_get_price_from_bars: {str(e)}")
+            return None
+    
+    def _try_get_price_from_snapshots(self, symbol: str) -> Optional[float]:
+        """Try to get price from the snapshots endpoint"""
+        try:
+            url = f"{self.data_url}/v1beta3/crypto/us/snapshots"
+            headers = {
+                "Apca-Api-Key-Id": self.api_key,
+                "Apca-Api-Secret-Key": self.api_secret
+            }
+            params = {"symbols": symbol}
+            
+            print(f"Getting current price from snapshots endpoint: {url} for symbol {symbol}")
+            response = requests.get(url, headers=headers, params=params)
+            
+            if response.status_code != 200:
+                print(f"Error getting price from snapshots: {response.status_code} - {response.text}")
+                return None
+            
+            data = response.json()
+            print(f"Snapshots response: {json.dumps(data)[:300]}...")
+            
+            if "snapshots" not in data or symbol not in data["snapshots"]:
+                print(f"No snapshot data found for {symbol}")
+                return None
+            
+            # Try to get price from latest bar in the snapshot
+            snapshot = data["snapshots"][symbol]
+            if "bar" in snapshot and snapshot["bar"]:
+                return float(snapshot["bar"]["c"])
+                
+            # Try to get price from latest quote in the snapshot
+            if "quote" in snapshot and snapshot["quote"]:
+                ask = snapshot["quote"].get("ap")
+                bid = snapshot["quote"].get("bp")
+                if ask and bid:
+                    return (float(ask) + float(bid)) / 2  # Average of bid and ask
+                elif ask:
+                    return float(ask)
+                elif bid:
+                    return float(bid)
+            
+            return None
+            
+        except Exception as e:
+            print(f"Error in _try_get_price_from_snapshots: {str(e)}")
+            return None
+    
+    def _try_get_price_from_orderbook(self, symbol: str) -> Optional[float]:
+        """Try to get price from the orderbook endpoint"""
+        try:
+            url = f"{self.data_url}/v1beta3/crypto/us/latest/orderbooks"
+            headers = {
+                "Apca-Api-Key-Id": self.api_key,
+                "Apca-Api-Secret-Key": self.api_secret
+            }
+            params = {"symbols": symbol}
+            
+            print(f"Getting current price from orderbook endpoint: {url} for symbol {symbol}")
+            response = requests.get(url, headers=headers, params=params)
+            
+            if response.status_code != 200:
+                print(f"Error getting price from orderbook: {response.status_code} - {response.text}")
+                return None
+            
+            data = response.json()
+            print(f"Orderbook response: {json.dumps(data)[:300]}...")
+            
+            if "orderbooks" not in data or symbol not in data["orderbooks"]:
+                print(f"No orderbook data found for {symbol}")
+                return None
+            
+            orderbook = data["orderbooks"][symbol]
+            
+            # Try to get mid price from best bid and ask
+            if "a" in orderbook and orderbook["a"] and "b" in orderbook and orderbook["b"]:
+                best_ask = float(orderbook["a"][0]["p"]) if orderbook["a"] else None
+                best_bid = float(orderbook["b"][0]["p"]) if orderbook["b"] else None
+                
+                if best_ask and best_bid:
+                    return (best_ask + best_bid) / 2  # Mid price
+                elif best_ask:
+                    return best_ask
+                elif best_bid:
+                    return best_bid
+            
+            return None
+            
+        except Exception as e:
+            print(f"Error in _try_get_price_from_orderbook: {str(e)}")
+            return None
+    
+    def _place_order(self, symbol: str, side: str, quantity: float, confidence: Optional[int] = None) -> Dict[str, Any]:
+        """Place a crypto order on Alpaca"""
+        try:
+            # Ensure proper symbol format
+            if symbol == "BTCUSD":
+                symbol = "BTC/USD"
+                print(f"Corrected symbol format from BTCUSD to {symbol} in _place_order")
+            elif symbol == "ETHUSD":
+                symbol = "ETH/USD"
+                print(f"Corrected symbol format from ETHUSD to {symbol} in _place_order")
+                
+            url = f"{self.base_url}/v2/orders"
+            
+            headers = {
+                "Apca-Api-Key-Id": self.api_key,
+                "Apca-Api-Secret-Key": self.api_secret,
+                "Content-Type": "application/json"
+            }
+            
+            # Ensure quantity is properly formatted
+            # Alpaca requires qty as a string with appropriate precision
+            if "BTC" in symbol:
+                qty_str = f"{quantity:.8f}".rstrip('0').rstrip('.') if '.' in f"{quantity:.8f}" else f"{quantity:.8f}"
+            else:
+                qty_str = f"{quantity:.4f}".rstrip('0').rstrip('.') if '.' in f"{quantity:.4f}" else f"{quantity:.4f}"
+            
+            print(f"Formatting quantity {quantity} as '{qty_str}' for API call")
+            
+            # Prepare the order data
+            order_data = {
+                "symbol": symbol,
+                "qty": qty_str,  # Use formatted string
+                "side": side,
+                "type": "market",
+                "time_in_force": "gtc"
+            }
+            
+            print(f"Sending order data to Alpaca: {json.dumps(order_data)}")
+            
+            # Add custom metadata if confidence is provided
+            if confidence is not None:
+                order_data["client_order_id"] = f"signal-{confidence}-{datetime.now().strftime('%Y%m%d%H%M%S')}"
+            
+            # Send the order request
+            response = requests.post(url, headers=headers, json=order_data)
+            
+            if response.status_code not in [200, 201]:
+                return {
+                    "error": f"Failed to place order: {response.text}",
+                    "success": False
+                }
+            
+            # Parse the response
+            order_response = response.json()
+            
+            # Get the current price for reference
+            current_price = self._get_current_price(symbol)
+            
+            # Return order details
+            return {
+                "order_id": order_response.get("id"),
+                "client_order_id": order_response.get("client_order_id"),
+                "symbol": order_response.get("symbol"),
+                "side": order_response.get("side"),
+                "quantity": order_response.get("qty"),
+                "order_type": order_response.get("type"),
+                "status": order_response.get("status"),
+                "current_price": current_price,
+                "created_at": order_response.get("created_at"),
+                "confidence": confidence,
+                "success": True
+            }
+            
+        except Exception as e:
+            return {
+                "error": f"Error placing order: {str(e)}",
+                "success": False
+            }
+    
+    def _get_positions(self, symbol: str = None) -> Dict[str, Any]:
+        """Get current positions from Alpaca"""
+        try:
+            # Ensure proper symbol format if provided
+            original_symbol = symbol
+            
+            # Normalize the symbol for comparison - can come in various formats
+            normalized_symbol = None
+            if symbol:
+                # Remove '/' for comparison if present
+                if '/' in symbol:
+                    normalized_symbol = symbol.replace('/', '')
+                else:
+                    # Add '/' if not present (e.g., BTCUSD -> BTC/USD)
+                    if symbol == "BTCUSD":
+                        normalized_symbol = "BTC/USD"
+                        symbol = "BTC/USD"
+                    elif symbol == "ETHUSD":
+                        normalized_symbol = "ETH/USD"
+                        symbol = "ETH/USD"
+                    else:
+                        # Try to insert a slash at the right place for other symbols
+                        if len(symbol) >= 6 and symbol[0:3].isalpha() and symbol[3:].isalpha():
+                            normalized_symbol = f"{symbol[0:3]}/{symbol[3:]}"
+                            symbol = normalized_symbol
+            
+            print(f"Getting positions for symbol: {symbol}, original input: {original_symbol}, normalized: {normalized_symbol}")
+            
+            url = f"{self.base_url}/v2/positions"
+            headers = {
+                "Apca-Api-Key-Id": self.api_key,
+                "Apca-Api-Secret-Key": self.api_secret
+            }
+            
+            # First get all positions to handle different symbol formats
+            response = requests.get(url, headers=headers)
+            
+            if response.status_code == 404:
+                # No positions found
+                print("No positions found (404 response)")
+                return {}
+                
+            if response.status_code != 200:
+                print(f"Error getting positions: {response.text}")
+                return {}
+            
+            positions_data = response.json()
+            
+            # If nothing was returned or not a list
+            if not positions_data or not isinstance(positions_data, list):
+                print(f"No positions data returned or unexpected format: {positions_data}")
+                return {}
+            
+            # If we're not looking for a specific symbol, return all positions
+            if not symbol:
+                return positions_data
+                
+            # Find position that matches our symbol in any format
+            for position in positions_data:
+                pos_symbol = position.get("symbol", "")
+                print(f"Checking position with symbol: {pos_symbol}")
+                
+                # Try different matching approaches to find BTC position
+                # 1. Direct match
+                if pos_symbol == symbol:
+                    print(f"Direct symbol match found: {pos_symbol}")
+                    return position
+                    
+                # 2. Normalized match (without slash)
+                if normalized_symbol and pos_symbol.replace('/', '') == normalized_symbol.replace('/', ''):
+                    print(f"Normalized symbol match found: {pos_symbol} matches {normalized_symbol}")
+                    return position
+                    
+                # 3. Match by asset name for crypto
+                if "BTC" in symbol.upper() and "BTC" in pos_symbol.upper():
+                    print(f"BTC match found in position symbol: {pos_symbol}")
+                    return position
+                    
+                # 4. Match by asset name for ETH
+                if "ETH" in symbol.upper() and "ETH" in pos_symbol.upper():
+                    print(f"ETH match found in position symbol: {pos_symbol}")
+                    return position
+            
+            # If we got here, no matching position was found
+            print(f"No matching position found for {symbol} among: {[p.get('symbol', 'N/A') for p in positions_data]}")
+            return {}
+            
+        except Exception as e:
+            print(f"Error getting positions: {str(e)}")
+            return {} 

src/crypto_analysis/tools/technical_tools.py

@@ -0,0 +1,436 @@
+import os
+import requests
+import json
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timedelta
+import pandas as pd
+import numpy as np
+import pytz  # Import pytz for timezone handling
+
+# Patch for pandas_ta NaN import issue
+import sys
+import importlib.util
+import inspect
+
+# Create a patched version of pandas_ta that won't try to import NaN from numpy
+try:
+    import pandas_ta as ta
+except ImportError as e:
+    if "cannot import name 'NaN' from 'numpy'" in str(e):
+        # Fix by monkeypatching numpy to provide NaN in expected location
+        np.NaN = np.nan
+        # Now import pandas_ta
+        import pandas_ta as ta
+    else:
+        raise
+
+# Import OpenAI for LLM strategy interpretation
+import openai
+from dotenv import load_dotenv
+load_dotenv()
+
+from crewai.tools import BaseTool
+from pydantic import Field
+from alpaca.data.historical import CryptoHistoricalDataClient
+from alpaca.data.requests import CryptoBarsRequest
+from alpaca.data.timeframe import TimeFrame, TimeFrameUnit
+
+# Set up OpenAI API key
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+class IndicatorCalculator:
+    """A modular class to calculate various technical indicators on price data."""
+    
+    # Dictionary of available indicators with their descriptions
+    AVAILABLE_INDICATORS = {
+        "rsi": "Relative Strength Index - measures momentum by comparing recent gains to recent losses",
+        "bollinger_bands": "Bollinger Bands - measure volatility with upper and lower bands",
+        "macd": "Moving Average Convergence Divergence - momentum indicator showing relationship between two moving averages",
+        "adx": "Average Directional Index - measures trend strength",
+        "ema": "Exponential Moving Average - gives more weight to recent prices",
+        "sma": "Simple Moving Average - arithmetic mean of prices over a period",
+        "atr": "Average True Range - measures volatility",
+        "stochastic": "Stochastic Oscillator - momentum indicator comparing close price to price range",
+        "obv": "On-Balance Volume - relates volume to price change"
+    }
+    
+    def __init__(self):
+        """Initialize the indicator calculator."""
+        pass
+    
+    def calculate_all_indicators(self, df: pd.DataFrame, params: Dict[str, Any] = None) -> pd.DataFrame:
+        """
+        Calculate all available indicators on the price data
+        
+        Args:
+            df: DataFrame with OHLCV data
+            params: Dictionary of parameters for indicators
+            
+        Returns:
+            DataFrame with added technical indicators
+        """
+        if params is None:
+            params = {}
+            
+        try:
+            # Ensure we're working with a DataFrame with expected columns
+            required_columns = ['open', 'high', 'low', 'close', 'volume']
+            missing_columns = [col for col in required_columns if col not in df.columns]
+            
+            if missing_columns:
+                print(f"Missing columns in dataframe: {missing_columns}")
+                print(f"Available columns: {df.columns}")
+                return df
+            
+            # Calculate RSI
+            rsi_length = params.get('rsi_length', 14)
+            df = self.calculate_rsi(df, length=rsi_length)
+            
+            # Calculate Bollinger Bands
+            bb_length = params.get('bb_length', 20)
+            bb_std = params.get('bb_std', 2.0)
+            df = self.calculate_bollinger_bands(df, length=bb_length, std=bb_std)
+            
+            # Calculate ADX
+            adx_length = params.get('adx_length', 14)
+            df = self.calculate_adx(df, length=adx_length)
+            
+            # Calculate EMAs
+            ema_lengths = params.get('ema_lengths', [8, 21, 50, 200])
+            for length in ema_lengths:
+                df = self.calculate_ema(df, length=length)
+            
+            # Calculate MACD
+            macd_fast = params.get('macd_fast', 12)
+            macd_slow = params.get('macd_slow', 26)
+            macd_signal = params.get('macd_signal', 9)
+            df = self.calculate_macd(df, fast=macd_fast, slow=macd_slow, signal=macd_signal)
+            
+            # Calculate Stochastic Oscillator
+            stoch_k = params.get('stoch_k', 14)
+            stoch_d = params.get('stoch_d', 3)
+            df = self.calculate_stochastic(df, k=stoch_k, d=stoch_d)
+            
+            # Calculate ATR
+            atr_length = params.get('atr_length', 14)
+            df = self.calculate_atr(df, length=atr_length)
+            
+            # Calculate OBV
+            df = self.calculate_obv(df)
+            
+            print(f"Calculated all technical indicators. Final data shape: {df.shape}")
+            
+            return df
+            
+        except Exception as e:
+            print(f"Error calculating indicators: {e}")
+            import traceback
+            traceback.print_exc()
+            return df
+    
+    def calculate_rsi(self, df: pd.DataFrame, length: int = 14) -> pd.DataFrame:
+        """Calculate RSI indicator."""
+        df[f'rsi_{length}'] = ta.rsi(df['close'], length=length)
+        return df
+    
+    def calculate_bollinger_bands(self, df: pd.DataFrame, length: int = 20, std: float = 2.0) -> pd.DataFrame:
+        """Calculate Bollinger Bands indicator."""
+        bbands = ta.bbands(df['close'], length=length, std=std)
+        df[f'bb_upper_{length}_{std}'] = bbands[f'BBU_{length}_{std}']
+        df[f'bb_middle_{length}_{std}'] = bbands[f'BBM_{length}_{std}']
+        df[f'bb_lower_{length}_{std}'] = bbands[f'BBL_{length}_{std}']
+        
+        # Normalize Bollinger Bands position (0 = lower band, 1 = upper band)
+        df[f'bb_position_{length}_{std}'] = (df['close'] - df[f'bb_lower_{length}_{std}']) / (df[f'bb_upper_{length}_{std}'] - df[f'bb_lower_{length}_{std}'])
+        
+        return df
+    
+    def calculate_adx(self, df: pd.DataFrame, length: int = 14) -> pd.DataFrame:
+        """Calculate ADX indicator."""
+        adx = ta.adx(df['high'], df['low'], df['close'], length=length)
+        df[f'adx_{length}'] = adx[f'ADX_{length}']
+        df[f'di_plus_{length}'] = adx[f'DMP_{length}']
+        df[f'di_minus_{length}'] = adx[f'DMN_{length}']
+        return df
+    
+    def calculate_ema(self, df: pd.DataFrame, length: int = 21) -> pd.DataFrame:
+        """Calculate EMA indicator."""
+        df[f'ema_{length}'] = ta.ema(df['close'], length=length)
+        return df
+    
+    def calculate_sma(self, df: pd.DataFrame, length: int = 21) -> pd.DataFrame:
+        """Calculate SMA indicator."""
+        df[f'sma_{length}'] = ta.sma(df['close'], length=length)
+        return df
+    
+    def calculate_macd(self, df: pd.DataFrame, fast: int = 12, slow: int = 26, signal: int = 9) -> pd.DataFrame:
+        """Calculate MACD indicator."""
+        macd = ta.macd(df['close'], fast=fast, slow=slow, signal=signal)
+        df[f'macd_{fast}_{slow}_{signal}'] = macd[f'MACD_{fast}_{slow}_{signal}']
+        df[f'macd_signal_{fast}_{slow}_{signal}'] = macd[f'MACDs_{fast}_{slow}_{signal}']
+        df[f'macd_histogram_{fast}_{slow}_{signal}'] = macd[f'MACDh_{fast}_{slow}_{signal}']
+        return df
+    
+    def calculate_stochastic(self, df: pd.DataFrame, k: int = 14, d: int = 3) -> pd.DataFrame:
+        """Calculate Stochastic Oscillator."""
+        stoch = ta.stoch(df['high'], df['low'], df['close'], k=k, d=d)
+        df[f'stoch_k_{k}'] = stoch[f'STOCHk_{k}_{d}_3']
+        df[f'stoch_d_{k}_{d}'] = stoch[f'STOCHd_{k}_{d}_3']
+        return df
+    
+    def calculate_atr(self, df: pd.DataFrame, length: int = 14) -> pd.DataFrame:
+        """Calculate Average True Range."""
+        df[f'atr_{length}'] = ta.atr(df['high'], df['low'], df['close'], length=length)
+        return df
+    
+    def calculate_obv(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Calculate On-Balance Volume."""
+        df['obv'] = ta.obv(df['close'], df['volume'])
+        return df
+    
+    @classmethod
+    def get_available_indicators(cls) -> Dict[str, str]:
+        """Return the dictionary of available indicators with descriptions."""
+        return cls.AVAILABLE_INDICATORS
+
+class TechnicalAnalysisStrategy(BaseTool):
+    name: str = "Bitcoin Technical Analysis Strategy Tool"
+    description: str = "Fetches current Bitcoin technical indicators data from the market"
+    
+    # Define all fields as proper Pydantic fields
+    api_key: Optional[str] = Field(default=None, description="Alpaca API key")
+    api_secret: Optional[str] = Field(default=None, description="Alpaca API secret")
+    client: Optional[Any] = Field(default=None, description="Alpaca client instance")
+    indicator_calculator: IndicatorCalculator = Field(default_factory=IndicatorCalculator, description="Indicator calculator instance")
+    
+    # Add model_config to allow arbitrary types
+    model_config = {"arbitrary_types_allowed": True}
+    
+    def __init__(self, **kwargs):
+        # Initialize the base class first
+        super().__init__(**kwargs)
+        
+        # Set the API keys from environment variables if not provided directly
+        if not self.api_key:
+            self.api_key = os.getenv("ALPACA_API_KEY")
+        if not self.api_secret:
+            self.api_secret = os.getenv("ALPACA_API_SECRET")
+        
+        print(f"Initializing Technical Analysis Strategy with API key: {'Present' if self.api_key else 'Missing'}")
+        
+        # Initialize the Alpaca client if not already set
+        if not self.client and self.api_key and self.api_secret:
+            try:
+                self.client = CryptoHistoricalDataClient(api_key=self.api_key, secret_key=self.api_secret)
+                print("Successfully initialized Alpaca client")
+            except Exception as e:
+                print(f"Error initializing Alpaca client: {e}")
+    
+    def _run(self) -> Dict[str, Any]:
+        """
+        Fetch Bitcoin technical indicator data
+        
+        Returns:
+            Dictionary with all technical indicators data
+        """
+        try:
+            print("Fetching Bitcoin technical indicator data")
+            
+            # Make sure client is initialized
+            if not self.client:
+                print("Client not initialized, attempting to create one now")
+                self.client = CryptoHistoricalDataClient(api_key=self.api_key, secret_key=self.api_secret)
+            
+            # Request extra periods to account for gaps in historical data
+            # Request 2x the minimum to ensure we get enough data points
+            min_required = 20  # Require fewer data points for basic analysis
+            lookback_periods = 100
+            actual_lookback = max(min_required, lookback_periods) * 3
+            timeframe_minutes = 5  # Default timeframe
+                
+            # Fetch the Bitcoin price data for the specified timeframe
+            df = self._fetch_price_data(actual_lookback, timeframe_minutes)
+            
+            if df is None:
+                print("No price data returned from fetch_price_data")
+                return {"error": "No price data available"}
+            
+            print(f"Retrieved {len(df)} data points")
+            
+            if len(df) < min_required:
+                print(f"Insufficient data points: {len(df)}, need at least {min_required}")
+                return {"error": f"Insufficient price data: only received {len(df)} data points"}
+            
+            # Calculate all indicators
+            indicator_params = {
+                'bb_std': 2.0,
+                'rsi_length': 14,
+                'bb_length': 20
+            }
+            df = self.indicator_calculator.calculate_all_indicators(df, indicator_params)
+            
+            # Get the latest data point with all indicators
+            latest_data = df.iloc[-1].to_dict()
+            
+            # Prepare result dictionary
+            result = {}
+            
+            # Add price data
+            result["price"] = float(latest_data.get('close', 0))
+            
+            # Add all indicators
+            for key, value in latest_data.items():
+                if key not in ['open', 'high', 'low', 'close', 'volume', 'time']:
+                    # Convert numpy values to Python native types
+                    if pd.isna(value):
+                        result[key] = None
+                    else:
+                        result[key] = float(value)
+            
+            return result
+            
+        except Exception as e:
+            print(f"Error fetching indicator data: {str(e)}")
+            return {"error": str(e)}
+    
+    def _fetch_price_data(self, lookback_periods: int, timeframe_minutes: int = 5) -> pd.DataFrame:
+        """
+        Fetch Bitcoin price data from Alpaca API
+        
+        Args:
+            lookback_periods: Number of periods to fetch
+            timeframe_minutes: Timeframe in minutes
+            
+        Returns:
+            DataFrame with OHLCV data
+        """
+        try:
+            # Calculate the start and end dates with timezone information
+            end = datetime.now(pytz.UTC)  # Make end timezone-aware with UTC
+            start = end - timedelta(minutes=timeframe_minutes * lookback_periods)
+            
+            print(f"Fetching price data from {start} to {end}")
+            
+            # Create the request parameters
+            request_params = CryptoBarsRequest(
+                symbol_or_symbols=["BTC/USD"],  # Use correct format with slash
+                timeframe=TimeFrame(timeframe_minutes, TimeFrameUnit.Minute),  # Use specified timeframe
+                start=start,
+                end=end
+            )
+            
+            print(f"Request parameters: {request_params}")
+            
+            # Get the bars data
+            bars = self.client.get_crypto_bars(request_params)
+            
+            if bars is None:
+                print("No bars data returned from API")
+                return None
+                
+            # Convert to dataframe
+            df = bars.df.reset_index()
+            
+            print(f"Raw data columns: {df.columns}")
+            print(f"Raw data shape: {df.shape}")
+            
+            # Print first few rows for debugging
+            print(f"First few rows: {df.head(2)}")
+            
+            # Ensure proper column names
+            if 'timestamp' in df.columns:
+                df = df.rename(columns={'timestamp': 'time'})
+            
+            # Filter to only BTC/USD data
+            if 'symbol' in df.columns:
+                df = df[df['symbol'] == 'BTC/USD'].reset_index(drop=True)
+                df = df.drop(columns=['symbol'])
+            
+            print(f"Processed data shape: {df.shape}")
+            return df
+            
+        except Exception as e:
+            print(f"Error fetching price data with SDK: {e}")
+            print(f"API Key present: {'Yes' if self.api_key else 'No'}")
+            print(f"API Secret present: {'Yes' if self.api_secret else 'No'}")
+            
+            # Try the direct REST API approach as fallback
+            try:
+                print("Attempting fallback to direct REST API call...")
+                return self._fetch_price_data_direct_api(lookback_periods, timeframe_minutes)
+            except Exception as e2:
+                print(f"Error in fallback API call: {e2}")
+                return None
+    
+    def _fetch_price_data_direct_api(self, lookback_periods: int, timeframe_minutes: int = 5) -> pd.DataFrame:
+        """
+        Fallback method to fetch Bitcoin price data using direct REST API calls
+        following the curl example format.
+        """
+        # Calculate the start and end dates
+        end = datetime.now(pytz.UTC)
+        start = end - timedelta(minutes=timeframe_minutes * lookback_periods)
+        
+        # Format dates for the API
+        start_str = start.strftime('%Y-%m-%dT%H:%M:%SZ')
+        end_str = end.strftime('%Y-%m-%dT%H:%M:%SZ')
+        
+        # Endpoint for historical bars
+        url = f"https://data.alpaca.markets/v1beta3/crypto/us/bars"
+        
+        # Query parameters
+        params = {
+            "symbols": "BTC/USD",
+            "timeframe": f"{timeframe_minutes}Min",
+            "start": start_str,
+            "end": end_str,
+            "limit": lookback_periods
+        }
+        
+        # Headers with authentication
+        headers = {
+            "Apca-Api-Key-Id": self.api_key,
+            "Apca-Api-Secret-Key": self.api_secret
+        }
+        
+        print(f"Making direct API call to: {url}")
+        print(f"With params: {params}")
+        
+        # Make the request
+        response = requests.get(url, params=params, headers=headers)
+        
+        if response.status_code != 200:
+            print(f"API Error: {response.status_code} - {response.text}")
+            return None
+        
+        # Parse response
+        data = response.json()
+        print(f"API Response: {json.dumps(data)[:300]}...")
+        
+        # Extract the bars
+        if 'bars' not in data or 'BTC/USD' not in data['bars']:
+            print("No bar data found in response")
+            return None
+            
+        bars_data = data['bars']['BTC/USD']
+        
+        # Create DataFrame
+        df = pd.DataFrame(bars_data)
+        
+        # Rename columns to match expected format
+        if 't' in df.columns:
+            df = df.rename(columns={
+                't': 'time',
+                'o': 'open',
+                'h': 'high',
+                'l': 'low',
+                'c': 'close',
+                'v': 'volume'
+            })
+            
+        # Convert timestamp to datetime
+        if 'time' in df.columns:
+            df['time'] = pd.to_datetime(df['time'])
+            
+        print(f"Processed API data shape: {df.shape}")
+        return df 

src/crypto_analysis/tools/yahoo_tools.py

@@ -0,0 +1,483 @@
+import os
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timedelta
+import pandas as pd
+import yfinance as yf
+from crewai.tools import BaseTool
+import time
+import logging
+import requests
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("yahoo_tools")
+
+class YahooBitcoinDataTool(BaseTool):
+    name: str = "Yahoo Finance Bitcoin Data Tool"
+    description: str = "Fetches Bitcoin price data from Yahoo Finance as an alternative data source"
+    max_retries: int = 3
+    backoff_factor: float = 2.0
+    timeout: int = 30
+    cache_duration_minutes: int = 15
+    cached_data: Dict[str, Dict[str, Any]] = {}
+    last_cache_time: Dict[str, datetime] = {}
+    
+    def __init__(self, max_retries: int = 3, backoff_factor: float = 2.0, timeout: int = 30, cache_duration_minutes: int = 15):
+        """
+        Initialize the tool with retry parameters
+        
+        Args:
+            max_retries: Maximum number of retry attempts (default: 3)
+            backoff_factor: Exponential backoff factor between retries (default: 2.0)
+            timeout: Request timeout in seconds (default: 30)
+            cache_duration_minutes: How long to cache results (default: 15 minutes)
+        """
+        super().__init__()
+        self.max_retries = max_retries
+        self.backoff_factor = backoff_factor
+        self.timeout = timeout
+        self.cache_duration_minutes = cache_duration_minutes
+        self.cached_data = {}  # Cache by period and interval
+        self.last_cache_time = {}  # Cache timestamps by period and interval
+    
+    def _check_cache_valid(self, period: str, interval: str) -> bool:
+        """
+        Check if the cached data is still valid
+        
+        Args:
+            period: The time period key
+            interval: The interval key
+            
+        Returns:
+            True if cache is valid, False otherwise
+        """
+        cache_key = f"{period}_{interval}"
+        
+        if cache_key not in self.cached_data or cache_key not in self.last_cache_time:
+            return False
+            
+        cache_age = datetime.now() - self.last_cache_time[cache_key]
+        return cache_age.total_seconds() < (self.cache_duration_minutes * 60)
+        
+    def _run(self, period: str = "1mo", interval: str = "1d") -> Dict[str, Any]:
+        """
+        Fetch Bitcoin price data from Yahoo Finance
+        
+        Args:
+            period: Time period to fetch data for (1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max)
+            interval: Time interval between data points (1m, 2m, 5m, 15m, 30m, 60m, 90m, 1h, 1d, 5d, 1wk, 1mo, 3mo)
+            
+        Returns:
+            Dictionary with OHLCV data and metadata
+        """
+        # Use cached data if available and valid
+        cache_key = f"{period}_{interval}"
+        if self._check_cache_valid(period, interval):
+            logger.info(f"Using cached Bitcoin data for period={period}, interval={interval}")
+            return self.cached_data[cache_key]
+        
+        logger.info(f"Fetching Bitcoin data for period={period}, interval={interval}")
+        
+        # BTC-USD ticker from Yahoo Finance
+        ticker = "BTC-USD"
+        
+        # Alternative tickers to try if primary fails
+        alternative_tickers = ["BTC-USD", "BTCUSD=X", "BTC=F"]
+        
+        data_dict = None
+        
+        # Try the primary ticker with retry logic
+        for attempt in range(self.max_retries):
+            try:
+                logger.info(f"Fetching {ticker} data (attempt {attempt + 1}/{self.max_retries})")
+                
+                # Get the data
+                data = yf.Ticker(ticker)
+                df = data.history(period=period, interval=interval, timeout=self.timeout)
+                
+                # Check if we have valid data
+                if df.empty:
+                    error_msg = f"{ticker}: possibly delisted; no price data found (period={period})"
+                    logger.warning(error_msg)
+                    # Don't retry with the same ticker, break to try alternatives
+                    break
+                
+                # Process the data
+                df = df.reset_index()
+                
+                # Ensure proper column names
+                if 'Date' in df.columns:
+                    df = df.rename(columns={'Date': 'time'})
+                elif 'Datetime' in df.columns:
+                    df = df.rename(columns={'Datetime': 'time'})
+                
+                # Standardize column names to lowercase
+                df.columns = [col.lower() for col in df.columns]
+                
+                # Convert numpy types to Python native types for JSON serialization
+                for col in df.columns:
+                    if col != 'time':
+                        df[col] = df[col].apply(lambda x: x.item() if hasattr(x, 'item') else x)
+                
+                # Metadata about Bitcoin from Yahoo Finance
+                info = data.info
+                
+                # Extract key information
+                market_cap = info.get('marketCap', None)
+                volume_24h = info.get('volume24Hr', None)
+                circulating_supply = info.get('circulatingSupply', None)
+                
+                # Convert to dictionary for JSON serialization
+                data_dict = {
+                    "dataframe": df.to_dict(orient='records'),
+                    "last_price": float(df['close'].iloc[-1]) if not df.empty else None,
+                    "time_period": period,
+                    "interval": interval,
+                    "ticker": ticker,
+                    "metadata": {
+                        "market_cap": market_cap,
+                        "volume_24h": volume_24h,
+                        "circulating_supply": circulating_supply,
+                        "last_updated": datetime.now().isoformat()
+                    }
+                }
+                
+                # Cache the data
+                self.cached_data[cache_key] = data_dict
+                self.last_cache_time[cache_key] = datetime.now()
+                logger.info(f"Cached Bitcoin data for period={period}, interval={interval}")
+                
+                return data_dict
+                
+            except requests.exceptions.Timeout as e:
+                wait_time = self.backoff_factor ** attempt
+                logger.warning(f"Timeout error for {ticker}: {str(e)}. Retrying in {wait_time:.1f} seconds...")
+                if attempt < self.max_retries - 1:
+                    time.sleep(wait_time)
+                else:
+                    logger.error(f"Max retries reached for {ticker}")
+                    # Don't return error yet, try alternative tickers
+                    break
+                    
+            except Exception as e:
+                logger.error(f"Error fetching data for {ticker}: {str(e)}")
+                # Don't return error yet, try alternative tickers
+                break
+        
+        # If we get here, the primary ticker failed - try alternatives
+        if data_dict is None:
+            for alt_ticker in alternative_tickers:
+                # Skip the one we already tried
+                if alt_ticker == ticker:
+                    continue
+                    
+                logger.info(f"Trying alternative ticker: {alt_ticker}")
+                
+                try:
+                    # Get the data with the alternative ticker
+                    data = yf.Ticker(alt_ticker)
+                    df = data.history(period=period, interval=interval, timeout=self.timeout)
+                    
+                    # Check if we have valid data
+                    if df.empty:
+                        logger.warning(f"{alt_ticker}: possibly delisted; no price data found (period={period})")
+                        continue
+                    
+                    # Process the data
+                    df = df.reset_index()
+                    
+                    # Ensure proper column names
+                    if 'Date' in df.columns:
+                        df = df.rename(columns={'Date': 'time'})
+                    elif 'Datetime' in df.columns:
+                        df = df.rename(columns={'Datetime': 'time'})
+                    
+                    # Standardize column names to lowercase
+                    df.columns = [col.lower() for col in df.columns]
+                    
+                    # Convert numpy types to Python native types for JSON serialization
+                    for col in df.columns:
+                        if col != 'time':
+                            df[col] = df[col].apply(lambda x: x.item() if hasattr(x, 'item') else x)
+                    
+                    # Metadata about Bitcoin from Yahoo Finance
+                    info = data.info
+                    
+                    # Extract key information
+                    market_cap = info.get('marketCap', None)
+                    volume_24h = info.get('volume24Hr', None)
+                    circulating_supply = info.get('circulatingSupply', None)
+                    
+                    # Convert to dictionary for JSON serialization
+                    data_dict = {
+                        "dataframe": df.to_dict(orient='records'),
+                        "last_price": float(df['close'].iloc[-1]) if not df.empty else None,
+                        "time_period": period,
+                        "interval": interval,
+                        "ticker": alt_ticker,
+                        "metadata": {
+                            "market_cap": market_cap,
+                            "volume_24h": volume_24h,
+                            "circulating_supply": circulating_supply,
+                            "last_updated": datetime.now().isoformat()
+                        },
+                        "note": f"Used alternative ticker {alt_ticker} because primary ticker failed"
+                    }
+                    
+                    # Cache the data
+                    self.cached_data[cache_key] = data_dict
+                    self.last_cache_time[cache_key] = datetime.now()
+                    logger.info(f"Cached Bitcoin data for period={period}, interval={interval} using alternate ticker {alt_ticker}")
+                    
+                    return data_dict
+                    
+                except Exception as e:
+                    logger.error(f"Error fetching data for alternative ticker {alt_ticker}: {str(e)}")
+                    continue
+        
+        # If we get here, all tickers failed
+        error_msg = f"Failed to fetch Bitcoin data for period={period}, interval={interval} with all available tickers"
+        logger.error(error_msg)
+        return {
+            "error": error_msg,
+            "time_period": period,
+            "interval": interval,
+            "tickers_tried": alternative_tickers
+        }
+
+
+class YahooCryptoMarketTool(BaseTool):
+    name: str = "Yahoo Finance Crypto Market Tool"
+    description: str = "Fetches data about the broader cryptocurrency market for contextual analysis"
+    max_retries: int = 3
+    backoff_factor: float = 2.0
+    timeout: int = 30
+    cache_duration_minutes: int = 30
+    cached_data: Dict[str, Any] = None
+    last_cache_time: datetime = None
+    
+    def __init__(self, max_retries: int = 3, backoff_factor: float = 2.0, timeout: int = 30, cache_duration_minutes: int = 30):
+        """
+        Initialize the tool with retry parameters
+        
+        Args:
+            max_retries: Maximum number of retry attempts (default: 3)
+            backoff_factor: Exponential backoff factor between retries (default: 2.0)
+            timeout: Request timeout in seconds (default: 30)
+            cache_duration_minutes: How long to cache results (default: 30 minutes)
+        """
+        super().__init__()
+        self.max_retries = max_retries
+        self.backoff_factor = backoff_factor
+        self.timeout = timeout
+        self.cache_duration_minutes = cache_duration_minutes
+        self.cached_data = None
+        self.last_cache_time = None
+
+    def _check_cache_valid(self) -> bool:
+        """
+        Check if the cached data is still valid
+        
+        Returns:
+            True if cache is valid, False otherwise
+        """
+        if self.cached_data is None or self.last_cache_time is None:
+            return False
+            
+        cache_age = datetime.now() - self.last_cache_time
+        return cache_age.total_seconds() < (self.cache_duration_minutes * 60)
+
+    def _get_ticker_data_with_retries(self, ticker: str) -> Dict[str, Any]:
+        """
+        Get ticker data with retry logic
+        
+        Args:
+            ticker: The ticker symbol to fetch
+            
+        Returns:
+            Dictionary with ticker data or error
+        """
+        for attempt in range(self.max_retries):
+            try:
+                logger.info(f"Fetching data for {ticker} (attempt {attempt + 1}/{self.max_retries})")
+                data = yf.Ticker(ticker)
+                
+                # Set a timeout for the history call
+                hist = data.history(period="5d", timeout=self.timeout)
+                info = data.info
+                
+                # Verify we have data
+                if hist.empty:
+                    logger.warning(f"{ticker}: possibly delisted; no price data found (period=5d)")
+                    return {
+                        "ticker": ticker,
+                        "error": f"{ticker}: possibly delisted; no price data found (period=5d)"
+                    }
+                
+                # Successfully got data, return it
+                return {
+                    "data": data,
+                    "hist": hist,
+                    "info": info
+                }
+                
+            except requests.exceptions.Timeout as e:
+                wait_time = self.backoff_factor ** attempt
+                logger.warning(f"Timeout error for {ticker}: {str(e)}. Retrying in {wait_time:.1f} seconds...")
+                if attempt < self.max_retries - 1:
+                    time.sleep(wait_time)
+                else:
+                    logger.error(f"Max retries reached for {ticker}")
+                    return {
+                        "ticker": ticker,
+                        "error": f"Timeout error after {self.max_retries} attempts: {str(e)}"
+                    }
+                    
+            except Exception as e:
+                logger.error(f"Error fetching data for {ticker}: {str(e)}")
+                return {
+                    "ticker": ticker,
+                    "error": str(e)
+                }
+                
+        return {
+            "ticker": ticker,
+            "error": "Unknown error during retry attempts"
+        }
+    
+    def _run(self, top_n: int = 10) -> Dict[str, Any]:
+        """
+        Fetch data about the top cryptocurrencies in the market
+        
+        Args:
+            top_n: Number of top cryptocurrencies to fetch data for
+            
+        Returns:
+            Dictionary with market data and trends
+        """
+        # Check if we have valid cached data
+        if self._check_cache_valid():
+            logger.info("Using cached cryptocurrency market data")
+            return self.cached_data
+            
+        logger.info(f"Fetching data for top {top_n} cryptocurrencies")
+        
+        try:
+            # Common crypto tickers to check
+            tickers = [
+                "BTC-USD",  # Bitcoin
+                "ETH-USD",  # Ethereum
+                "XRP-USD",  # Ripple
+                "SOL-USD",  # Solana
+                "ADA-USD",  # Cardano
+                "AVAX-USD", # Avalanche
+                "DOT-USD",  # Polkadot
+                "DOGE-USD", # Dogecoin
+                "LINK-USD", # Chainlink
+                "MATIC-USD" # Polygon
+            ]
+            
+            # Limit to requested number
+            tickers = tickers[:min(top_n, len(tickers))]
+            
+            results = []
+            market_cap_sum = 0
+            btc_dominance = 0
+            btc_market_cap = 0
+            success_count = 0
+            error_count = 0
+            
+            # Fetch data for each ticker
+            for ticker in tickers:
+                ticker_data = self._get_ticker_data_with_retries(ticker)
+                
+                if "error" in ticker_data:
+                    # Handle error case - add basic info with error message
+                    error_count += 1
+                    results.append({
+                        "ticker": ticker,
+                        "name": ticker.split('-')[0],
+                        "error": ticker_data["error"],
+                        "data_available": False
+                    })
+                    continue
+                
+                # Extract data
+                data = ticker_data["data"]
+                hist = ticker_data["hist"]
+                info = ticker_data["info"]
+                
+                success_count += 1
+                
+                if not hist.empty:
+                    current_price = hist['Close'].iloc[-1]
+                    day_change = ((current_price / hist['Close'].iloc[-2]) - 1) * 100 if len(hist) > 1 else 0
+                    week_change = ((current_price / hist['Close'].iloc[0]) - 1) * 100 if len(hist) > 4 else day_change
+                    
+                    market_cap = info.get('marketCap', 0)
+                    market_cap_sum += market_cap if market_cap else 0
+                    
+                    # Store BTC market cap for dominance calculation
+                    if ticker == "BTC-USD":
+                        btc_market_cap = market_cap if market_cap else 0
+                    
+                    # Convert numpy types to Python native types for JSON serialization
+                    if hasattr(current_price, 'item'):
+                        current_price = current_price.item()
+                    if hasattr(day_change, 'item'):
+                        day_change = day_change.item()
+                    if hasattr(week_change, 'item'):
+                        week_change = week_change.item()
+                    
+                    results.append({
+                        "ticker": ticker,
+                        "name": info.get('shortName', ticker.split('-')[0]),
+                        "current_price": current_price,
+                        "market_cap": market_cap,
+                        "volume_24h": info.get('volume24Hr', None),
+                        "day_change_percent": day_change,
+                        "week_change_percent": week_change,
+                        "data_available": True
+                    })
+            
+            # Calculate BTC dominance
+            if market_cap_sum > 0 and btc_market_cap > 0:
+                btc_dominance = (btc_market_cap / market_cap_sum) * 100
+            
+            # Overall market trends - only count assets with data
+            valid_results = [r for r in results if r.get("data_available", False)]
+            market_trend = "bullish" if sum(r.get('day_change_percent', 0) for r in valid_results) > 0 else "bearish"
+            
+            # Create response
+            response = {
+                "cryptocurrencies": results,
+                "market_summary": {
+                    "total_market_cap": market_cap_sum,
+                    "btc_dominance": btc_dominance,
+                    "market_trend": market_trend,
+                    "timestamp": datetime.now().isoformat(),
+                    "success_count": success_count,
+                    "error_count": error_count,
+                    "total_count": len(tickers)
+                }
+            }
+            
+            # Cache the result if we got at least some data
+            if success_count > 0:
+                self.cached_data = response
+                self.last_cache_time = datetime.now()
+                logger.info(f"Cached cryptocurrency market data (success: {success_count}, errors: {error_count})")
+            
+            return response
+            
+        except Exception as e:
+            logger.error(f"Error in YahooCryptoMarketTool: {str(e)}")
+            return {
+                "error": str(e),
+                "market_summary": {
+                    "market_trend": "unknown",
+                    "timestamp": datetime.now().isoformat(),
+                    "error": str(e)
+                },
+                "cryptocurrencies": []
+            } 

src/crypto_analysis/utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+Shared utility functions for the crypto analysis package
+""" 

src/crypto_analysis/utils/api_helpers.py

@@ -0,0 +1,231 @@
+"""
+API helper utilities for reliable data fetching with retry logic
+"""
+import time
+import logging
+import functools
+import numpy as np
+from typing import Any, Dict, Optional, Callable, TypeVar, cast, Union
+import pandas as pd
+import requests
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_exponential,
+    retry_if_exception_type,
+    RetryError
+)
+
+# Set up logging
+logger = logging.getLogger("api_helpers")
+
+# Type variable for return type of functions
+T = TypeVar('T')
+
+def validate_dataframe(df: pd.DataFrame, required_columns: list, min_rows: int = 1) -> bool:
+    """
+    Validate that a pandas DataFrame meets minimum requirements
+    
+    Args:
+        df: DataFrame to validate
+        required_columns: List of column names that must be present
+        min_rows: Minimum number of rows required
+        
+    Returns:
+        True if valid, False otherwise
+    """
+    # Check if DataFrame is empty
+    if df is None or df.empty or len(df) < min_rows:
+        logger.warning(f"DataFrame validation failed: empty or too few rows (expected {min_rows}, got {0 if df is None or df.empty else len(df)})")
+        return False
+    
+    # Check for required columns
+    missing_columns = [col for col in required_columns if col not in df.columns]
+    if missing_columns:
+        logger.warning(f"DataFrame validation failed: missing columns {missing_columns}")
+        return False
+    
+    return True
+
+def convert_numpy_types(obj: Any) -> Any:
+    """
+    Convert numpy types to native Python types for JSON serialization
+    
+    Args:
+        obj: Object that might contain numpy types
+        
+    Returns:
+        Object with numpy types converted to Python types
+    """
+    if isinstance(obj, np.integer):
+        return int(obj)
+    elif isinstance(obj, np.floating):
+        return float(obj)
+    elif isinstance(obj, np.ndarray):
+        return obj.tolist()
+    elif isinstance(obj, pd.DataFrame):
+        return obj.to_dict(orient='records')
+    elif isinstance(obj, pd.Series):
+        return obj.to_dict()
+    elif isinstance(obj, dict):
+        return {k: convert_numpy_types(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [convert_numpy_types(item) for item in obj]
+    else:
+        return obj
+
+def safe_api_call(
+    func: Callable[..., T],
+    max_retries: int = 3,
+    backoff_factor: float = 2.0,
+    timeout: int = 30,
+    expected_exceptions: tuple = (requests.exceptions.RequestException,),
+    validation_func: Optional[Callable[[T], bool]] = None
+) -> Callable[..., Dict[str, Any]]:
+    """
+    Decorator for safely making API calls with retries and error handling
+    
+    Args:
+        func: Function to wrap
+        max_retries: Maximum number of retry attempts
+        backoff_factor: Exponential backoff factor
+        timeout: Request timeout in seconds
+        expected_exceptions: Exceptions to retry on
+        validation_func: Optional function to validate the response
+        
+    Returns:
+        Wrapped function that returns a dict with either data or error
+    """
+    @functools.wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Wrapper function that adds retry logic and error handling
+        
+        Returns:
+            Dictionary with either successful data or error information
+        """
+        try:
+            # Add the timeout parameter if it's a keyword argument in the original function
+            if 'timeout' in kwargs:
+                # Only override if not explicitly provided
+                if kwargs['timeout'] is None:
+                    kwargs['timeout'] = timeout
+            
+            # Apply the retry decorator dynamically
+            retried_func = retry(
+                stop=stop_after_attempt(max_retries),
+                wait=wait_exponential(multiplier=1, min=backoff_factor, max=backoff_factor * 10),
+                retry=retry_if_exception_type(expected_exceptions),
+                reraise=True
+            )(func)
+            
+            # Call the function with retries
+            result = retried_func(*args, **kwargs)
+            
+            # Validate result if validation function is provided
+            if validation_func and not validation_func(result):
+                return {
+                    "success": False,
+                    "error": "Data validation failed",
+                    "data": None
+                }
+            
+            # Convert numpy types for JSON serialization
+            result = convert_numpy_types(result)
+            
+            return {
+                "success": True,
+                "data": result,
+                "error": None
+            }
+            
+        except RetryError as e:
+            # This means we exceeded max retries
+            original_error = e.__cause__
+            logger.error(f"Max retries exceeded in {func.__name__}: {str(original_error)}")
+            return {
+                "success": False,
+                "error": f"Max retries exceeded: {str(original_error)}",
+                "data": None
+            }
+            
+        except Exception as e:
+            logger.error(f"Error in {func.__name__}: {str(e)}", exc_info=True)
+            return {
+                "success": False,
+                "error": str(e),
+                "data": None
+            }
+    
+    return wrapper
+
+def with_exponential_backoff(
+    max_retries: int = 3,
+    backoff_factor: float = 2.0,
+    expected_exceptions: tuple = (Exception,)
+) -> Callable[[Callable[..., T]], Callable[..., T]]:
+    """
+    Decorator for adding exponential backoff retry logic to any function
+    
+    Args:
+        max_retries: Maximum number of retry attempts
+        backoff_factor: Exponential backoff factor
+        expected_exceptions: Exceptions to retry on
+        
+    Returns:
+        Decorator function
+    """
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> T:
+            """
+            Wrapper function that adds retry logic
+            
+            Returns:
+                Result of the original function
+            """
+            for attempt in range(max_retries):
+                try:
+                    return func(*args, **kwargs)
+                except expected_exceptions as e:
+                    if attempt == max_retries - 1:
+                        # Last attempt, re-raise the exception
+                        raise
+                    
+                    # Calculate wait time with exponential backoff
+                    wait_time = backoff_factor ** attempt
+                    logger.warning(f"Attempt {attempt + 1}/{max_retries} failed: {str(e)}. Retrying in {wait_time:.1f} seconds...")
+                    time.sleep(wait_time)
+            
+            # This should not be reached, but return a sensible default
+            return cast(T, None)
+        
+        return wrapper
+    
+    return decorator
+
+def handle_api_result(
+    result: Dict[str, Any], 
+    default_value: T, 
+    error_prefix: str = "API Error"
+) -> Union[T, Dict[str, Any]]:
+    """
+    Handle the result from a safe_api_call wrapped function
+    
+    Args:
+        result: The result dictionary from safe_api_call
+        default_value: Default value to return if the API call failed
+        error_prefix: Prefix for error message
+        
+    Returns:
+        Either the successful data or an error dictionary
+    """
+    if result.get("success", False):
+        return result.get("data", default_value)
+    else:
+        error_msg = f"{error_prefix}: {result.get('error', 'Unknown error')}"
+        logger.error(error_msg)
+        return {
+            "error": error_msg,
+            "data": default_value
+        } 

src/stock_analysis/config/agents.yaml

@@ -0,0 +1,30 @@
+financial_analyst:
+  role: >
+    The Best Financial Analyst
+  goal: >
+    Impress all customers with your financial data and market trends analysis
+  backstory: >
+    The most seasoned financial analyst with lots of expertise in stock market analysis and investment
+    strategies that is working for a super important customer.
+
+research_analyst:
+  role: >
+    Staff Research Analyst
+  goal: >
+    Being the best at gathering, interpreting data and amazing
+    your customer with it
+  backstory: >
+    Known as the BEST research analyst, you're skilled in sifting through news, company announcements,
+    and market sentiments. Now you're working on a super important customer.
+
+investment_advisor:
+  role: >
+    Private Investment Advisor
+  goal: >
+    Impress your customers with full analyses over stocks
+    and complete investment recommendations
+  backstory: >
+    You're the most experienced investment advisor
+    and you combine various analytical insights to formulate
+    strategic investment advice. You are now working for
+    a super important customer you need to impress.

src/stock_analysis/config/tasks.yaml

@@ -0,0 +1,51 @@
+financial_analysis:
+  description: >
+    Conduct a thorough analysis of {company_stock}'s stock financial health and market performance. This includes examining key financial metrics such as
+    P/E ratio, EPS growth, revenue trends, and debt-to-equity ratio. Also, analyze the stock's performance in comparison 
+    to its industry peers and overall market trends.
+
+  expected_output: >
+    The final report must expand on the summary provided but now 
+    including a clear assessment of the stock's financial standing, its strengths and weaknesses, 
+    and how it fares against its competitors in the current market scenario.
+    Make sure to use the most recent data possible.
+
+research:
+  description: >
+    Collect and summarize recent news articles, press
+    releases, and market analyses related to the {company_stock} stock and its industry.
+    Pay special attention to any significant events, market sentiments, and analysts' opinions. 
+    Also include upcoming events like earnings and others.
+
+  expected_output: >
+    A report that includes a comprehensive summary of the latest news, 
+    any notable shifts in market sentiment, and potential impacts on the stock. Also make sure to return the stock ticker as {company_stock}.
+    Make sure to use the most recent data as possible.
+
+filings_analysis:
+  description: >
+    Analyze the latest 10-Q and 10-K filings from EDGAR for the stock {company_stock} in question. 
+    Focus on key sections like Management's Discussion and analysis, financial statements, insider trading activity, 
+    and any disclosed risks. Extract relevant data and insights that could influence
+    the stock's future performance.
+
+  expected_output: >
+    Final answer must be an expanded report that now also highlights significant findings
+    from these filings including any red flags or positive indicators for your customer.
+
+recommend:
+  description: >
+    Review and synthesize the analyses provided by the
+    Financial Analyst and the Research Analyst.
+    Combine these insights to form a comprehensive
+    investment recommendation. You MUST Consider all aspects, including financial
+    health, market sentiment, and qualitative data from
+    EDGAR filings. 
+    
+    Make sure to include a section that shows insider 
+    trading activity, and upcoming events like earnings.
+
+  expected_output: > 
+    Your final answer MUST be a recommendation for your customer. It should be a full super detailed report, providing a 
+    clear investment stance and strategy with supporting evidence.
+    Make it pretty and well formatted for your customer.

src/stock_analysis/crew.py

@@ -0,0 +1,123 @@
+from typing import List
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+
+from tools.calculator_tool import CalculatorTool
+from tools.sec_tools import SEC10KTool, SEC10QTool
+
+from crewai_tools import WebsiteSearchTool, ScrapeWebsiteTool, TXTSearchTool
+
+from dotenv import load_dotenv
+load_dotenv()
+
+from langchain.llms import Ollama
+llm = Ollama(model="llama3.1")
+
+@CrewBase
+class StockAnalysisCrew:
+    agents_config = 'config/agents.yaml'
+    tasks_config = 'config/tasks.yaml'
+    
+    @agent
+    def financial_agent(self) -> Agent:
+        return Agent(
+            config=self.agents_config['financial_analyst'],
+            verbose=True,
+            llm=llm,
+            tools=[
+                ScrapeWebsiteTool(),
+                WebsiteSearchTool(),
+                CalculatorTool(),
+                SEC10QTool("AMZN"),
+                SEC10KTool("AMZN"),
+            ]
+        )
+    
+    @task
+    def financial_analysis(self) -> Task: 
+        return Task(
+            config=self.tasks_config['financial_analysis'],
+            agent=self.financial_agent(),
+        )
+    
+
+    @agent
+    def research_analyst_agent(self) -> Agent:
+        return Agent(
+            config=self.agents_config['research_analyst'],
+            verbose=True,
+            llm=llm,
+            tools=[
+                ScrapeWebsiteTool(),
+                # WebsiteSearchTool(), 
+                SEC10QTool("AMZN"),
+                SEC10KTool("AMZN"),
+            ]
+        )
+    
+    @task
+    def research(self) -> Task:
+        return Task(
+            config=self.tasks_config['research'],
+            agent=self.research_analyst_agent(),
+        )
+    
+    @agent
+    def financial_analyst_agent(self) -> Agent:
+        return Agent(
+            config=self.agents_config['financial_analyst'],
+            verbose=True,
+            llm=llm,
+            tools=[
+                ScrapeWebsiteTool(),
+                WebsiteSearchTool(),
+                CalculatorTool(),
+                SEC10QTool(),
+                SEC10KTool(),
+            ]
+        )
+    
+    @task
+    def financial_analysis(self) -> Task: 
+        return Task(
+            config=self.tasks_config['financial_analysis'],
+            agent=self.financial_analyst_agent(),
+        )
+    
+    @task
+    def filings_analysis(self) -> Task:
+        return Task(
+            config=self.tasks_config['filings_analysis'],
+            agent=self.financial_analyst_agent(),
+        )
+
+    @agent
+    def investment_advisor_agent(self) -> Agent:
+        return Agent(
+            config=self.agents_config['investment_advisor'],
+            verbose=True,
+            llm=llm,
+            tools=[
+                ScrapeWebsiteTool(),
+                WebsiteSearchTool(),
+                CalculatorTool(),
+            ]
+        )
+
+    @task
+    def recommend(self) -> Task:
+        return Task(
+            config=self.tasks_config['recommend'],
+            agent=self.investment_advisor_agent(),
+        )
+    
+    
+    @crew
+    def crew(self) -> Crew:
+        """Creates the Stock Analysis"""
+        return Crew(
+            agents=self.agents,  
+            tasks=self.tasks, 
+            process=Process.sequential,
+            verbose=True,
+        )

src/stock_analysis/main.py

@@ -0,0 +1,32 @@
+import sys
+from crew import StockAnalysisCrew
+
+def run():
+    inputs = {
+        'query': 'What is the company you want to analyze?',
+        'company_stock': 'AMZN',
+    }
+    return StockAnalysisCrew().crew().kickoff(inputs=inputs)
+
+def train():
+    """
+    Train the crew for a given number of iterations.
+    """
+    inputs = {
+        'query': 'What is last years revenue',
+        'company_stock': 'AMZN',
+    }
+    try:
+        StockAnalysisCrew().crew().train(n_iterations=int(sys.argv[1]), inputs=inputs)
+
+    except Exception as e:
+        raise Exception(f"An error occurred while training the crew: {e}")
+    
+if __name__ == "__main__":
+    print("## Welcome to Stock Analysis Crew")
+    print('-------------------------------')
+    result = run()
+    print("\n\n########################")
+    print("## Here is the Report")
+    print("########################\n")
+    print(result)

src/stock_analysis/tools/calculator_tool.py

@@ -0,0 +1,12 @@
+from crewai_tools import BaseTool
+
+
+class CalculatorTool(BaseTool):
+    name: str = "Calculator tool"
+    description: str = (
+        "Useful to perform any mathematical calculations, like sum, minus, multiplication, division, etc. The input to this tool should be a mathematical  expression, a couple examples are `200*7` or `5000/2*10."
+    )
+
+    def _run(self, operation: str) -> int:
+        # Implementation goes here
+        return eval(operation)

src/stock_analysis/tools/sec_tools.py

@@ -0,0 +1,170 @@
+import os
+from typing import Any, Optional, Type
+from pydantic.v1 import BaseModel, Field
+from crewai_tools import RagTool
+from sec_api import QueryApi  # Make sure to have sec_api installed
+from embedchain.models.data_type import DataType
+import requests
+import html2text
+import re
+
+class FixedSEC10KToolSchema(BaseModel):
+    """Input for SEC10KTool."""
+    search_query: str = Field(
+        ...,
+        description="Mandatory query you would like to search from the 10-K report",
+    )
+
+class SEC10KToolSchema(FixedSEC10KToolSchema):
+    """Input for SEC10KTool."""
+    stock_name: str = Field(
+        ..., description="Mandatory valid stock name you would like to search"
+    )
+
+class SEC10KTool(RagTool):
+    name: str = "Search in the specified 10-K form"
+    description: str = "A tool that can be used to semantic search a query from a 10-K form for a specified company."
+    args_schema: Type[BaseModel] = SEC10KToolSchema
+
+    def __init__(self, stock_name: Optional[str] = None, **kwargs):
+        print("enter init")
+        # exit()
+        super().__init__(**kwargs)
+        if stock_name is not None:
+            content = self.get_10k_url_content(stock_name)
+            if content:
+                self.add(content)
+                # print("exit init")
+                # exit()
+                self.description = f"A tool that can be used to semantic search a query from {stock_name}'s latest 10-K SEC form's content as a txt file."
+                self.args_schema = FixedSEC10KToolSchema
+                self._generate_description()
+
+    def get_10k_url_content(self, stock_name: str) -> Optional[str]:
+        """Fetches the URL content as txt of the latest 10-K form for the given stock name."""
+        try:
+            queryApi = QueryApi(api_key=os.environ['SEC_API_API_KEY'])
+            query = {
+                "query": {
+                    "query_string": {
+                        "query": f"ticker:{stock_name} AND formType:\"10-K\""
+                    }
+                },
+                "from": "0",
+                "size": "1",
+                "sort": [{ "filedAt": { "order": "desc" }}]
+            }
+            filings = queryApi.get_filings(query)['filings']
+            if len(filings) == 0:
+                print("No filings found for this stock.")
+                return None
+
+            url = filings[0]['linkToFilingDetails']
+            
+            headers = {
+                "User-Agent": "crewai.com bisan@crewai.com",
+                "Accept-Encoding": "gzip, deflate",
+                "Host": "www.sec.gov"
+            }
+            response = requests.get(url, headers=headers)
+            response.raise_for_status()  
+            h = html2text.HTML2Text()
+            h.ignore_links = False
+            text = h.handle(response.content.decode("utf-8"))
+
+            text = re.sub(r"[^a-zA-Z$0-9\s\n]", "", text)
+            return text
+        except requests.exceptions.HTTPError as e:
+            print(f"HTTP error occurred: {e}")
+            return None
+        except Exception as e:
+            print(f"Error fetching 10-K URL: {e}")
+            return None
+
+    def add(self, *args: Any, **kwargs: Any) -> None:
+        kwargs["data_type"] = DataType.TEXT
+        super().add(*args, **kwargs)
+
+    def _run(self, search_query: str, **kwargs: Any) -> Any:
+        return super()._run(query=search_query, **kwargs)
+
+
+class FixedSEC10QToolSchema(BaseModel):
+    """Input for SEC10QTool."""
+    search_query: str = Field(
+        ...,
+        description="Mandatory query you would like to search from the 10-Q report",
+    )
+
+class SEC10QToolSchema(FixedSEC10QToolSchema):
+    """Input for SEC10QTool."""
+    stock_name: str = Field(
+        ..., description="Mandatory valid stock name you would like to search"
+    )
+
+class SEC10QTool(RagTool):
+    name: str = "Search in the specified 10-Q form"
+    description: str = "A tool that can be used to semantic search a query from a 10-Q form for a specified company."
+    args_schema: Type[BaseModel] = SEC10QToolSchema
+
+    def __init__(self, stock_name: Optional[str] = None, **kwargs):
+        print("enter init")
+        # exit()
+        super().__init__(**kwargs)
+        if stock_name is not None:
+            content = self.get_10q_url_content(stock_name)
+            if content:
+                self.add(content)
+                self.description = f"A tool that can be used to semantic search a query from {stock_name}'s latest 10-Q SEC form's content as a txt file."
+                self.args_schema = FixedSEC10QToolSchema
+                self._generate_description()
+
+    def get_10q_url_content(self, stock_name: str) -> Optional[str]:
+        """Fetches the URL content as txt of the latest 10-Q form for the given stock name."""
+        try:
+            queryApi = QueryApi(api_key=os.environ['SEC_API_API_KEY'])
+            query = {
+                "query": {
+                    "query_string": {
+                        "query": f"ticker:{stock_name} AND formType:\"10-Q\""
+                    }
+                },
+                "from": "0",
+                "size": "1",
+                "sort": [{ "filedAt": { "order": "desc" }}]
+            }
+            filings = queryApi.get_filings(query)['filings']
+            if len(filings) == 0:
+                print("No filings found for this stock.")
+                return None
+
+            url = filings[0]['linkToFilingDetails']
+            
+            headers = {
+                "User-Agent": "crewai.com bisan@crewai.com",
+                "Accept-Encoding": "gzip, deflate",
+                "Host": "www.sec.gov"
+            }
+            response = requests.get(url, headers=headers)
+            response.raise_for_status()  # Raise an exception for HTTP errors
+            h = html2text.HTML2Text()
+            h.ignore_links = False
+            text = h.handle(response.content.decode("utf-8"))
+
+            # Removing all non-English words, dollar signs, numbers, and newlines from text
+            text = re.sub(r"[^a-zA-Z$0-9\s\n]", "", text)
+            return text
+        except requests.exceptions.HTTPError as e:
+            print(f"HTTP error occurred: {e}")
+            return None
+        except Exception as e:
+            print(f"Error fetching 10-Q URL: {e}")
+            return None
+
+    def add(self, *args: Any, **kwargs: Any) -> None:
+        kwargs["data_type"] = DataType.TEXT
+        super().add(*args, **kwargs)
+
+    def _run(self, search_query: str, **kwargs: Any) -> Any:
+        return super()._run(query=search_query, **kwargs)
+

src/ui/__init__.py

@@ -0,0 +1,8 @@
+"""
+CrypticAI UI Package
+
+This package contains the user interface components for the CrypticAI Bitcoin
+Trading Dashboard.
+"""
+
+__version__ = "0.1.0" 

src/ui/app.py

@@ -0,0 +1,1657 @@
+import os
+import sys
+import time
+import json
+import gradio as gr
+import threading
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import matplotlib.pyplot as plt
+import requests
+import sqlite3
+from typing import Dict, Any, List, Optional
+import openai
+
+# Add project root to path for imports
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
+
+# Import necessary modules
+from src.crypto_analysis.tools.technical_tools import TechnicalAnalysisStrategy, IndicatorCalculator
+from src.crypto_analysis.tools.order_tools import AlpacaCryptoOrderTool
+from src.crypto_analysis.tools.bitcoin_tools import YahooBitcoinDataTool
+from src.crypto_analysis.tools.yahoo_tools import YahooCryptoMarketTool
+from src.crypto_analysis.crew import BitcoinAnalysisCrew
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+# Initialize the database
+DB_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../data/cryptic.db'))
+os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+
+def init_database():
+    """Initialize the SQLite database with necessary tables"""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    # Create strategies table
+    cursor.execute('''
+    CREATE TABLE IF NOT EXISTS strategies (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        description TEXT,
+        strategy_text TEXT NOT NULL,
+        parameters TEXT NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )
+    ''')
+    
+    # Create transactions table
+    cursor.execute('''
+    CREATE TABLE IF NOT EXISTS transactions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        symbol TEXT NOT NULL,
+        action TEXT NOT NULL,
+        quantity REAL NOT NULL,
+        price REAL NOT NULL,
+        status TEXT NOT NULL,
+        allocation_percentage INTEGER,
+        order_id TEXT,
+        strategy_id INTEGER,
+        reasoning TEXT,
+        timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (strategy_id) REFERENCES strategies (id)
+    )
+    ''')
+    
+    # Create analysis_results table
+    cursor.execute('''
+    CREATE TABLE IF NOT EXISTS analysis_results (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        signal TEXT NOT NULL,
+        confidence INTEGER,
+        allocation_percentage INTEGER,
+        reasoning TEXT,
+        indicator_values TEXT,
+        strategy_id INTEGER,
+        timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (strategy_id) REFERENCES strategies (id)
+    )
+    ''')
+    
+    conn.commit()
+    conn.close()
+
+# Initialize the database when module is loaded
+init_database()
+
+# Global variables for strategy parameters
+strategy_params = {
+    "timeframe_minutes": 60,
+    "max_allocation_percentage": 50,
+    "strategy_text": None
+}
+
+# Store analysis results and orders
+analysis_results = []
+orders_history = []
+active_trades = []
+
+# Flag to control the background thread
+running = False
+background_thread = None
+
+# Function to get available strategies from the database
+def get_saved_strategies():
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("SELECT id, name, description FROM strategies")
+    strategies = [{"id": row[0], "name": row[1], "description": row[2]} for row in cursor.fetchall()]
+    conn.close()
+    return strategies
+
+# Function to get a specific strategy by ID
+def get_strategy_by_id(strategy_id):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("SELECT id, name, description, strategy_text, parameters FROM strategies WHERE id = ?", (strategy_id,))
+    row = cursor.fetchone()
+    conn.close()
+    
+    if row:
+        return {
+            "id": row[0],
+            "name": row[1],
+            "description": row[2],
+            "strategy_text": row[3],
+            "parameters": json.loads(row[4])
+        }
+    return None
+
+# Function to save a strategy to the database
+def save_strategy(name, description, strategy_text, parameters):
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+        
+        # Check if strategy name already exists
+        cursor.execute("SELECT id FROM strategies WHERE name = ?", (name,))
+        existing = cursor.fetchone()
+        
+        if existing:
+            # Update existing strategy
+            cursor.execute(
+                "UPDATE strategies SET description = ?, strategy_text = ?, parameters = ? WHERE name = ?",
+                (description, strategy_text, json.dumps(parameters), name)
+            )
+        else:
+            # Insert new strategy
+            cursor.execute(
+                "INSERT INTO strategies (name, description, strategy_text, parameters) VALUES (?, ?, ?, ?)",
+                (name, strategy_text, strategy_text, json.dumps(parameters))
+            )
+        
+        conn.commit()
+        conn.close()
+        return True, "Strategy saved successfully"
+    except Exception as e:
+        return False, f"Error saving strategy: {str(e)}"
+
+# Function to save analysis result to the database
+def save_analysis_result(result, strategy_id=None):
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+        
+        # Extract values from result
+        signal = result.get("signal", "unknown")
+        confidence = result.get("confidence", 0)
+        allocation_percentage = result.get("allocation_percentage", 0)
+        reasoning = result.get("reasoning", "")
+        
+        # Convert technical indicators to JSON string
+        indicator_values = json.dumps(result.get("technical_indicators", {}))
+        
+        # Insert into database
+        cursor.execute(
+            "INSERT INTO analysis_results (signal, confidence, allocation_percentage, reasoning, indicator_values, strategy_id) VALUES (?, ?, ?, ?, ?, ?)",
+            (signal, confidence, allocation_percentage, reasoning, indicator_values, strategy_id)
+        )
+        
+        conn.commit()
+        conn.close()
+        return True
+    except Exception as e:
+        print(f"Error saving analysis result: {e}")
+        return False
+
+# Function to save transaction to the database
+def save_transaction(order_data, strategy_id=None):
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+        
+        # Extract values from order data
+        symbol = order_data.get("symbol", "BTC/USD")
+        action = order_data.get("action", "unknown")
+        quantity = order_data.get("quantity", 0)
+        price = order_data.get("price", 0)
+        status = order_data.get("status", "unknown")
+        allocation_percentage = order_data.get("allocation_percentage", 0)
+        order_id = order_data.get("order_id", "")
+        reasoning = order_data.get("reasoning", "")
+        
+        # Insert into database
+        cursor.execute(
+            "INSERT INTO transactions (symbol, action, quantity, price, status, allocation_percentage, order_id, strategy_id, reasoning) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            (symbol, action, quantity, price, status, allocation_percentage, order_id, strategy_id, reasoning)
+        )
+        
+        conn.commit()
+        conn.close()
+        return True
+    except Exception as e:
+        print(f"Error saving transaction: {e}")
+        return False
+
+# Function to get recent analysis results from the database
+def get_recent_analysis_results(limit=10):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("""
+        SELECT ar.id, ar.signal, ar.confidence, ar.allocation_percentage, ar.reasoning, 
+               ar.timestamp, s.name as strategy_name 
+        FROM analysis_results ar
+        LEFT JOIN strategies s ON ar.strategy_id = s.id
+        ORDER BY ar.timestamp DESC
+        LIMIT ?
+    """, (limit,))
+    
+    results = []
+    for row in cursor.fetchall():
+        results.append({
+            "id": row[0],
+            "signal": row[1],
+            "confidence": row[2],
+            "allocation_percentage": row[3],
+            "reasoning": row[4],
+            "timestamp": row[5],
+            "strategy_name": row[6] or "Default Strategy"
+        })
+    
+    conn.close()
+    return results
+
+# Function to get recent transactions from the database
+def get_recent_transactions(limit=10):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("""
+        SELECT t.id, t.symbol, t.action, t.quantity, t.price, t.status, 
+               t.allocation_percentage, t.timestamp, s.name as strategy_name 
+        FROM transactions t
+        LEFT JOIN strategies s ON t.strategy_id = s.id
+        ORDER BY t.timestamp DESC
+        LIMIT ?
+    """, (limit,))
+    
+    transactions = []
+    for row in cursor.fetchall():
+        transactions.append({
+            "id": row[0],
+            "symbol": row[1],
+            "action": row[2],
+            "quantity": row[3],
+            "price": row[4],
+            "status": row[5],
+            "allocation_percentage": row[6],
+            "timestamp": row[7],
+            "strategy_name": row[8] or "Default Strategy"
+        })
+    
+    conn.close()
+    return transactions
+
+# Function to fetch account information
+def fetch_account_info():
+    try:
+        order_tool = AlpacaCryptoOrderTool()
+        account_data = order_tool._check_account()
+        return account_data
+    except Exception as e:
+        print(f"Error fetching account info: {e}")
+        return {"error": str(e), "cash": 0, "equity": 0}
+
+# Function to reset portfolio (close all positions)
+def reset_portfolio():
+    try:
+        # Create a session with authentication
+        api_key = os.getenv("ALPACA_API_KEY")
+        api_secret = os.getenv("ALPACA_API_SECRET")
+        
+        headers = {
+            "APCA-API-KEY-ID": api_key,
+            "APCA-API-SECRET-KEY": api_secret
+        }
+        
+        # Use paper trading URL
+        base_url = "https://paper-api.alpaca.markets"
+        
+        # 1. First cancel all open orders
+        response = requests.delete(f"{base_url}/v2/orders", headers=headers)
+        if response.status_code != 204 and response.status_code != 200:
+            print(f"Error canceling orders: {response.status_code}, {response.text}")
+            return f"Error canceling orders: {response.status_code}"
+        
+        # 2. Then close all positions
+        response = requests.delete(f"{base_url}/v2/positions", headers=headers)
+        if response.status_code != 204 and response.status_code != 200:
+            print(f"Error closing positions: {response.status_code}, {response.text}")
+            return f"Error closing positions: {response.status_code}"
+        
+        return "Portfolio reset successfully. All positions closed and orders canceled."
+    except Exception as e:
+        print(f"Error resetting portfolio: {e}")
+        return f"Error resetting portfolio: {str(e)}"
+
+# Function to fetch order history
+def fetch_order_history():
+    try:
+        # Create a session with authentication
+        api_key = os.getenv("ALPACA_API_KEY")
+        api_secret = os.getenv("ALPACA_API_SECRET")
+        
+        headers = {
+            "APCA-API-KEY-ID": api_key,
+            "APCA-API-SECRET-KEY": api_secret
+        }
+        
+        # Use paper trading URL
+        base_url = "https://paper-api.alpaca.markets"
+        
+        # Fetch orders
+        response = requests.get(f"{base_url}/v2/orders?status=all&limit=100", headers=headers)
+        
+        if response.status_code == 200:
+            orders = response.json()
+            # Filter for BTC orders and format them
+            btc_orders = [order for order in orders if "BTC" in order.get("symbol", "")]
+            
+            formatted_orders = []
+            for order in btc_orders:
+                formatted_orders.append({
+                    "id": order["id"],
+                    "symbol": order["symbol"],
+                    "side": order["side"],
+                    "type": order["type"],
+                    "qty": order["qty"],
+                    "status": order["status"],
+                    "created_at": order["created_at"],
+                    "filled_at": order.get("filled_at", "N/A"),
+                    "filled_qty": order.get("filled_qty", "0"),
+                    "filled_avg_price": order.get("filled_avg_price", "0")
+                })
+            
+            return formatted_orders
+        else:
+            print(f"Error fetching orders: {response.status_code}, {response.text}")
+            return []
+    except Exception as e:
+        print(f"Error in fetch_order_history: {e}")
+        return []
+
+# Function to fetch active positions
+def fetch_active_positions():
+    try:
+        api_key = os.getenv("ALPACA_API_KEY")
+        api_secret = os.getenv("ALPACA_API_SECRET")
+        
+        headers = {
+            "APCA-API-KEY-ID": api_key,
+            "APCA-API-SECRET-KEY": api_secret
+        }
+        
+        base_url = "https://paper-api.alpaca.markets"
+        
+        # Fetch positions
+        response = requests.get(f"{base_url}/v2/positions", headers=headers)
+        
+        if response.status_code == 200:
+            positions = response.json()
+            # Filter for BTC positions
+            btc_positions = [pos for pos in positions if "BTC" in pos.get("symbol", "")]
+            
+            formatted_positions = []
+            for pos in btc_positions:
+                # Calculate profit/loss
+                current_price = float(pos.get("current_price", 0))
+                avg_entry_price = float(pos.get("avg_entry_price", 0))
+                qty = float(pos.get("qty", 0))
+                
+                profit_loss = (current_price - avg_entry_price) * qty
+                profit_loss_percent = ((current_price / avg_entry_price) - 1) * 100 if avg_entry_price > 0 else 0
+                
+                formatted_positions.append({
+                    "symbol": pos["symbol"],
+                    "qty": pos["qty"],
+                    "avg_entry_price": pos["avg_entry_price"],
+                    "current_price": pos["current_price"],
+                    "profit_loss": round(profit_loss, 2),
+                    "profit_loss_percent": round(profit_loss_percent, 2),
+                    "market_value": pos["market_value"],
+                    "side": pos["side"]
+                })
+            
+            return formatted_positions
+        else:
+            print(f"Error fetching positions: {response.status_code}, {response.text}")
+            return []
+    except Exception as e:
+        print(f"Error in fetch_active_positions: {e}")
+        return []
+
+# Function to run technical analysis with just the TA agent
+def run_ta_agent_only(strategy_text=None):
+    try:
+        tech_strategy = TechnicalAnalysisStrategy()
+        
+        # Use the provided strategy text or the global one
+        strategy_text = strategy_text or strategy_params.get("strategy_text")
+        
+        if not strategy_text:
+            return {
+                "error": "No strategy text provided",
+                "signal": "hold",
+                "confidence": 0,
+                "allocation_percentage": 0,
+                "reasoning": "Please enter a strategy description first"
+            }
+        
+        # Get the indicator data from the tool
+        indicator_data = tech_strategy._run()
+        
+        if "error" in indicator_data:
+            return {
+                "error": indicator_data["error"],
+                "signal": "hold",
+                "confidence": 0,
+                "allocation_percentage": 0,
+                "reasoning": f"Error fetching indicator data: {indicator_data['error']}"
+            }
+        
+        # Use OpenAI to interpret the strategy based on the indicator data
+        signal_data = interpret_strategy_with_llm(indicator_data, strategy_text, strategy_params["max_allocation_percentage"])
+        
+        # Add timestamp
+        signal_data["timestamp"] = datetime.now().isoformat()
+        
+        # Add to analysis results
+        analysis_results.append(signal_data)
+        
+        # Save to database
+        save_analysis_result(signal_data)
+        
+        return signal_data
+    except Exception as e:
+        print(f"Error running TA agent: {e}")
+        return {"error": str(e)}
+
+# New function to interpret strategy with LLM
+def interpret_strategy_with_llm(indicator_data, strategy_text, max_allocation_percentage=50):
+    try:
+        # Create the system prompt for the LLM
+        system_prompt = """
+        You are a cryptocurrency trading strategy interpreter. Your task is to analyze the provided technical 
+        indicators and price data, then interpret the user's strategy to generate a trading signal.
+        
+        You must return a JSON object with the following fields:
+        - signal: "buy", "sell", or "hold"
+        - confidence: Integer between 0-95 (how confident you are in the signal)
+        - allocation_percentage: Integer between 0-{max_allocation} (how much of the portfolio to allocate)
+        - reasoning: String explanation of your decision process
+        
+        Be pragmatic and conservative. Only give buy/sell signals when the conditions are clearly met.
+        Base your decision on the indicator values, not on general market sentiment or news.
+        """
+        
+        # Prepare price data - might need to be retrieved from indicator_data
+        price = indicator_data.get("price", 0)
+        
+        # Create the user prompt with all the data
+        user_prompt = f"""
+        # Technical Indicators
+        {json.dumps(indicator_data, indent=2)}
+        
+        # Strategy Description
+        {strategy_text}
+        
+        Analyze the above data according to the strategy description and generate a trading signal.
+        Respond only with JSON. Maximum allocation is {max_allocation_percentage}%.
+        """
+        
+        # Make the call to OpenAI
+        response = openai.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": system_prompt.format(max_allocation=max_allocation_percentage)},
+                {"role": "user", "content": user_prompt}
+            ],
+            temperature=0.2,
+            response_format={"type": "json_object"}
+        )
+        
+        # Extract and parse the response content
+        response_content = response.choices[0].message.content
+        result = json.loads(response_content)
+        
+        # Ensure the result has the expected fields
+        if not all(k in result for k in ["signal", "confidence", "allocation_percentage", "reasoning"]):
+            missing = [k for k in ["signal", "confidence", "allocation_percentage", "reasoning"] if k not in result]
+            print(f"LLM response missing required fields: {missing}")
+            result = {
+                "signal": result.get("signal", "hold"),
+                "confidence": result.get("confidence", 50),
+                "allocation_percentage": result.get("allocation_percentage", 0),
+                "reasoning": result.get("reasoning", "No reasoning provided.")
+            }
+        
+        # Ensure values are within expected ranges
+        result["confidence"] = max(0, min(95, int(result["confidence"])))
+        result["allocation_percentage"] = max(0, min(max_allocation_percentage, int(result["allocation_percentage"])))
+        
+        # Add indicator values to the result
+        result["technical_indicators"] = indicator_data
+        
+        print(f"LLM generated signal: {result['signal']} with confidence {result['confidence']}%")
+        return result
+        
+    except Exception as e:
+        print(f"Error interpreting strategy with LLM: {e}")
+        import traceback
+        traceback.print_exc()
+        return {
+            "signal": "hold",
+            "confidence": 0,
+            "allocation_percentage": 0,
+            "reasoning": f"Error interpreting strategy with LLM: {str(e)}"
+        }
+
+# Function to run the full analysis using the crew
+def run_full_analysis():
+    try:
+        # Get the strategy text from global parameters
+        strategy_text = strategy_params.get("strategy_text")
+        
+        if not strategy_text:
+            return {
+                "error": "No strategy text provided",
+                "signal": "hold",
+                "confidence": 0,
+                "allocation_percentage": 0,
+                "reasoning": "Please enter a strategy description first"
+            }
+        
+        crew = BitcoinAnalysisCrew()
+        result = crew.run_analysis(strategy_text=strategy_text)
+        
+        # Add timestamp
+        result["timestamp"] = datetime.now().isoformat()
+        
+        # Add to analysis results
+        analysis_results.append(result)
+        
+        # Save to database
+        save_analysis_result(result)
+        
+        # Check if order was executed, if so add to orders
+        if "order_execution" in result and isinstance(result["order_execution"], dict):
+            if result["order_execution"].get("success", False):
+                orders_history.append(result["order_execution"])
+                save_transaction(result["order_execution"])
+        
+        return result
+    except Exception as e:
+        print(f"Error running crew analysis: {e}")
+        return {"error": str(e)}
+
+# Background process function 
+def background_process():
+    global running
+    
+    # Create a log file for the automated trading session
+    log_file = os.path.join(os.path.dirname(DB_PATH), f"auto_trading_log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt")
+    with open(log_file, 'w') as f:
+        f.write(f"Automated trading session started at {datetime.now().isoformat()}\n")
+        f.write(f"Strategy parameters: {json.dumps(strategy_params)}\n\n")
+    
+    error_count = 0
+    max_errors = 5
+    
+    while running:
+        try:
+            print(f"Running full crew analysis at {datetime.now().isoformat()} with params: {strategy_params}")
+            
+            # Log to file as well
+            with open(log_file, 'a') as f:
+                f.write(f"\n--- Analysis run at {datetime.now().isoformat()} ---\n")
+            
+            # Check if strategy text is available
+            if not strategy_params.get("strategy_text"):
+                print("No strategy text available for automated analysis. Skipping.")
+                with open(log_file, 'a') as f:
+                    f.write("No strategy text available for automated analysis. Skipping.\n")
+                time.sleep(60)  # Sleep for a minute and check again
+                continue
+            
+            # Run the full crew analysis instead of just TA agent
+            result = run_full_analysis()
+            print(f"Analysis result: {result.get('signal', 'unknown')} with confidence {result.get('confidence', 0)}%")
+            
+            # Log the result
+            with open(log_file, 'a') as f:
+                f.write(f"Signal: {result.get('signal', 'unknown')}, Confidence: {result.get('confidence', 0)}%, Allocation: {result.get('allocation_percentage', 0)}%\n")
+                f.write(f"Reasoning: {result.get('reasoning', 'No reasoning provided')}\n")
+                
+                # Log order execution details if any
+                if "order_execution" in result and result["order_execution"]:
+                    order_details = result["order_execution"]
+                    if isinstance(order_details, dict):
+                        f.write(f"Order executed: {order_details.get('action', 'unknown')} {order_details.get('quantity', 0)} BTC at ${order_details.get('price', 0)}\n")
+                    else:
+                        f.write(f"Order info: {str(order_details)}\n")
+            
+            # Update the active trades
+            positions = fetch_active_positions()
+            global active_trades
+            active_trades = positions
+            
+            # Log current positions
+            with open(log_file, 'a') as f:
+                f.write("\nCurrent Positions:\n")
+                if positions:
+                    for pos in positions:
+                        f.write(f"  {pos['symbol']}: {pos['qty']} @ ${pos['avg_entry_price']} - P/L: ${pos['profit_loss']} ({pos['profit_loss_percent']}%)\n")
+                else:
+                    f.write("  No active positions\n")
+                
+                # Log account info
+                account = fetch_account_info()
+                f.write(f"\nAccount Balance: ${account.get('cash', 'N/A')}, Equity: ${account.get('equity', 'N/A')}\n")
+            
+            # Reset error counter on successful run
+            error_count = 0
+            
+            # Sleep for the specified timeframe interval
+            interval_seconds = strategy_params["timeframe_minutes"] * 60
+            print(f"Sleeping for {interval_seconds} seconds ({strategy_params['timeframe_minutes']} minutes)")
+            
+            # Sleep in smaller increments to allow for quicker stopping
+            for _ in range(min(interval_seconds, 3600), 0, -10):  # Sleep in 10-second increments
+                if not running:
+                    break
+                time.sleep(10)
+                
+        except Exception as e:
+            error_count += 1
+            error_message = f"Error in background process: {str(e)}"
+            print(error_message)
+            import traceback
+            trace = traceback.format_exc()
+            print(trace)
+            
+            # Log error
+            with open(log_file, 'a') as f:
+                f.write(f"\nERROR: {error_message}\n")
+                f.write(trace + "\n")
+            
+            # If too many consecutive errors, pause for a longer time
+            if error_count >= max_errors:
+                print(f"Too many errors ({error_count}). Pausing for 30 minutes.")
+                with open(log_file, 'a') as f:
+                    f.write(f"Too many errors ({error_count}). Pausing for 30 minutes.\n")
+                
+                # Sleep but still check for stop signal
+                for _ in range(1800, 0, -10):
+                    if not running:
+                        break
+                    time.sleep(10)
+                
+                # Reset error count after pause
+                error_count = 0
+            else:
+                # Short pause before retrying
+                time.sleep(60)
+
+# Function to start the background process
+def start_background_process():
+    global running, background_thread
+    
+    if not running:
+        running = True
+        background_thread = threading.Thread(target=background_process)
+        background_thread.daemon = True
+        background_thread.start()
+        return f"Background analysis started. Running full crew analysis every {strategy_params['timeframe_minutes']} minutes."
+    else:
+        return "Background analysis is already running."
+
+# Function to stop the background process
+def stop_background_process():
+    global running
+    
+    if running:
+        running = False
+        return "Background analysis stopped."
+    else:
+        return "Background analysis is not running."
+
+# Function to update strategy parameters
+def update_strategy(timeframe, max_allocation):
+    global strategy_params
+    
+    try:
+        # Convert values to appropriate types
+        timeframe = int(timeframe)
+        max_allocation = int(max_allocation)
+        
+        # Update the global dictionary
+        strategy_params["timeframe_minutes"] = timeframe
+        strategy_params["max_allocation_percentage"] = max_allocation
+        
+        print(f"Updated strategy parameters: {strategy_params}")
+        
+        return f"Strategy parameters updated: Timeframe: {timeframe} minutes, Max allocation: {max_allocation}%"
+    except Exception as e:
+        return f"Error updating strategy parameters: {e}"
+
+# Function to update custom strategy text
+def update_strategy_text(strategy_text):
+    global strategy_params
+    
+    try:
+        strategy_params["strategy_text"] = strategy_text
+        print(f"Updated strategy text: {strategy_text[:100]}...")
+        return "Strategy text updated successfully"
+    except Exception as e:
+        return f"Error updating strategy text: {e}"
+
+# Function to save current strategy
+def save_current_strategy(name, description):
+    try:
+        # Get current strategy parameters
+        parameters = strategy_params.copy()
+        strategy_text = parameters.get("strategy_text", "")
+        
+        # If strategy text is empty, provide a default description
+        if not strategy_text:
+            strategy_text = f"Default RSI ({parameters['rsi_lower_threshold']}-{parameters['rsi_upper_threshold']}) and Bollinger Bands strategy"
+        
+        # Save to database
+        success, message = save_strategy(name, description, strategy_text, parameters)
+        
+        if success:
+            return f"Strategy '{name}' saved successfully"
+        else:
+            return message
+    except Exception as e:
+        return f"Error saving strategy: {e}"
+
+# Function to run a manual trade
+def execute_trade(action, symbol, allocation_pct):
+    try:
+        order_tool = AlpacaCryptoOrderTool()
+        
+        result = order_tool._run(
+            action=action,
+            symbol=symbol,
+            allocation_percentage=int(allocation_pct)
+        )
+        
+        if result.get("success", False):
+            orders_history.append(result)
+            # Save to database
+            save_transaction(result)
+            return f"Trade executed: {action.upper()} {symbol} with {allocation_pct}% allocation"
+        else:
+            return f"Trade failed: {result.get('error', 'Unknown error')}"
+    except Exception as e:
+        return f"Error executing trade: {e}"
+
+# Function to get account summary for display
+def get_account_summary():
+    account = fetch_account_info()
+    positions = fetch_active_positions()
+    
+    cash = account.get("cash", "0")
+    equity = account.get("equity", "0")
+    
+    total_positions = len(positions)
+    total_value = sum(float(pos.get("market_value", 0)) for pos in positions)
+    total_pl = sum(pos.get("profit_loss", 0) for pos in positions)
+    
+    return f"""
+    **Account Summary**
+    - Cash: ${cash}
+    - Equity: ${equity}
+    - Active Positions: {total_positions}
+    - Positions Value: ${total_value:.2f}
+    - Total P/L: ${total_pl:.2f}
+    """
+
+# Function to format analysis results for display
+def format_analysis_results():
+    # First try to get from database
+    db_results = get_recent_analysis_results(1)
+    
+    if db_results:
+        latest = db_results[0]
+        
+        timestamp = latest.get("timestamp", datetime.now().isoformat())
+        signal = latest.get("signal", "unknown").upper()
+        confidence = latest.get("confidence", 0)
+        allocation = latest.get("allocation_percentage", 0)
+        reasoning = latest.get("reasoning", "No reasoning provided.")
+        strategy_name = latest.get("strategy_name", "Default Strategy")
+        
+        return f"""
+        **Latest Analysis ({timestamp})**
+        
+        Strategy: {strategy_name}
+        Signal: {signal}
+        Confidence: {confidence}%
+        Allocation: {allocation}%
+        
+        Reasoning:
+        {reasoning}
+        """
+    
+    # Fallback to memory if database is empty
+    if not analysis_results:
+        return "No analysis results available."
+    
+    latest = analysis_results[-1]
+    
+    timestamp = latest.get("timestamp", datetime.now().isoformat())
+    signal = latest.get("signal", "unknown").upper()
+    confidence = latest.get("confidence", 0)
+    allocation = latest.get("allocation_percentage", 0)
+    reasoning = latest.get("reasoning", "No reasoning provided.")
+    
+    return f"""
+    **Latest Analysis ({timestamp})**
+    
+    Signal: {signal}
+    Confidence: {confidence}%
+    Allocation: {allocation}%
+    
+    Reasoning:
+    {reasoning}
+    """
+
+# Function to format active positions for display
+def format_active_positions():
+    positions = fetch_active_positions()
+    
+    if not positions:
+        return "No active positions."
+    
+    result = "## Active Positions\n\n"
+    
+    for pos in positions:
+        result += f"""
+        **{pos['symbol']}**  
+        Quantity: {pos['qty']} BTC  
+        Entry: ${pos['avg_entry_price']}  
+        Current: ${pos['current_price']}  
+        P/L: ${pos['profit_loss']} ({pos['profit_loss_percent']}%)  
+        Value: ${pos['market_value']}  
+        
+        """
+    
+    return result
+
+# Function to format order history for display
+def format_order_history():
+    # Try to get from database first
+    db_transactions = get_recent_transactions(10)
+    
+    if db_transactions:
+        result = "## Recent Transactions\n\n"
+        
+        for tx in db_transactions:
+            result += f"""
+            **{tx['symbol']} {tx['action'].upper()}**  
+            Quantity: {tx['quantity']}  
+            Price: ${tx['price']}  
+            Status: {tx['status']}  
+            Allocation: {tx['allocation_percentage']}%  
+            Date: {tx['timestamp']}  
+            Strategy: {tx['strategy_name']}  
+            
+            """
+        
+        return result
+    
+    # Fall back to API if database is empty
+    orders = fetch_order_history()
+    
+    if not orders:
+        return "No order history."
+    
+    result = "## Order History (Last 10)\n\n"
+    
+    for order in orders[:10]:
+        result += f"""
+        **{order['symbol']} {order['side'].upper()}**  
+        Quantity: {order['qty']}  
+        Type: {order['type']}  
+        Status: {order['status']}  
+        Created: {order['created_at']}  
+        Filled: {order.get('filled_at', 'N/A')}  
+        Filled Price: ${order.get('filled_avg_price', 'N/A')}  
+        
+        """
+    
+    return result
+
+# Function to get available indicators for display
+def get_available_indicators():
+    indicators = IndicatorCalculator.get_available_indicators()
+    
+    result = "## Available Indicators\n\n"
+    
+    for name, description in indicators.items():
+        result += f"**{name}**: {description}\n\n"
+    
+    return result
+
+# Function to format detailed analysis results for display
+def format_detailed_analysis_results(result=None):
+    if result is None:
+        # First try to get from database
+        db_results = get_recent_analysis_results(1)
+        if db_results:
+            result = db_results[0]
+        elif analysis_results:
+            result = analysis_results[-1]
+        else:
+            return "No analysis results available."
+    
+    # Basic information
+    timestamp = result.get("timestamp", datetime.now().isoformat())
+    signal = result.get("signal", "unknown").upper()
+    confidence = result.get("confidence", 0)
+    allocation = result.get("allocation_percentage", 0)
+    reasoning = result.get("reasoning", "No reasoning provided.")
+    strategy_name = result.get("strategy_name", "Default Strategy")
+    
+    # Detailed sections
+    sections = []
+    
+    # Add header
+    sections.append(f"## Analysis Results ({timestamp})")
+    sections.append(f"### Strategy: {strategy_name}")
+    sections.append(f"### Signal: {signal} | Confidence: {confidence}% | Allocation: {allocation}%")
+    
+    # Technical indicator values (if available)
+    if "technical_indicators" in result:
+        sections.append("### Technical Indicators")
+        indicators = result["technical_indicators"]
+        indicators_text = []
+        
+        # Display price first
+        if "price" in indicators:
+            indicators_text.append(f"- **Price**: ${indicators['price']:.2f}")
+        
+        # Display RSI values
+        rsi_indicators = {k: v for k, v in indicators.items() if "rsi" in k.lower() and v is not None}
+        if rsi_indicators:
+            indicators_text.append("- **RSI**:")
+            for k, v in rsi_indicators.items():
+                indicators_text.append(f"  - {k}: {v:.2f}")
+        
+        # Display Bollinger Bands
+        bb_indicators = {k: v for k, v in indicators.items() if "bb_" in k.lower() and v is not None}
+        if bb_indicators:
+            indicators_text.append("- **Bollinger Bands**:")
+            for k, v in bb_indicators.items():
+                indicators_text.append(f"  - {k}: {v:.2f}")
+        
+        # Display MACD
+        macd_indicators = {k: v for k, v in indicators.items() if "macd" in k.lower() and v is not None}
+        if macd_indicators:
+            indicators_text.append("- **MACD**:")
+            for k, v in macd_indicators.items():
+                indicators_text.append(f"  - {k}: {v:.2f}")
+        
+        # Display other indicators
+        other_indicators = {k: v for k, v in indicators.items() 
+                           if not any(x in k.lower() for x in ["rsi", "bb_", "macd", "price"]) 
+                           and v is not None}
+        if other_indicators:
+            indicators_text.append("- **Other Indicators**:")
+            for k, v in other_indicators.items():
+                indicators_text.append(f"  - {k}: {v:.2f}")
+        
+        sections.append("\n".join(indicators_text))
+    
+    # Add technical analysis section
+    if "technical_analysis" in result:
+        sections.append("### Technical Analysis")
+        sections.append(f"```\n{result['technical_analysis']}\n```")
+    
+    # Add initial analysis section
+    if "initial_analysis" in result:
+        sections.append("### Market Context Analysis")
+        sections.append(f"```\n{result['initial_analysis']}\n```")
+    
+    # Add reflection analysis section
+    if "reflection_analysis" in result:
+        sections.append("### Sentiment Analysis")
+        sections.append(f"```\n{result['reflection_analysis']}\n```")
+    
+    # Add tool errors section if present
+    if "tool_error_summary" in result or "tool_error_assessment" in result:
+        sections.append("### Data Limitations")
+        if "tool_error_assessment" in result:
+            sections.append(f"```\n{result['tool_error_assessment']}\n```")
+        if "tool_error_summary" in result:
+            sections.append(f"Tool Errors: {result['tool_error_summary']}")
+    
+    # Add detailed reasoning
+    sections.append("### Detailed Reasoning")
+    sections.append(f"```\n{reasoning}\n```")
+    
+    # Add market outlook if available
+    if "market_outlook" in result:
+        sections.append("### Market Outlook")
+        sections.append(f"```\n{result['market_outlook']}\n```")
+    
+    # Add risk assessment if available
+    if "risk_assessment" in result:
+        sections.append("### Risk Assessment")
+        sections.append(f"```\n{result['risk_assessment']}\n```")
+    
+    # Add order execution details if available
+    if "order_execution" in result:
+        sections.append("### Trade Execution")
+        if isinstance(result["order_execution"], dict):
+            order = result["order_execution"]
+            order_details = ["- **Status**: Success"]
+            for k, v in order.items():
+                if k != "success":
+                    order_details.append(f"- **{k.replace('_', ' ').title()}**: {v}")
+            sections.append("\n".join(order_details))
+        else:
+            sections.append(str(result["order_execution"]))
+    
+    return "\n\n".join(sections)
+
+# Create the Gradio interface
+with gr.Blocks(title="CrypticAI - Bitcoin Trading Dashboard") as app:
+    gr.Markdown("# CrypticAI - Bitcoin Trading Dashboard")
+    
+    with gr.Tabs():
+        # Strategy Tab
+        with gr.TabItem("Strategy Configuration"):
+            gr.Markdown("## Strategy Parameters")
+            
+            with gr.Row():
+                with gr.Column():
+                    timeframe = gr.Slider(minimum=1, maximum=240, value=strategy_params["timeframe_minutes"], step=1,
+                                        label="Timeframe (minutes)")
+                
+                with gr.Column():
+                    max_allocation = gr.Slider(minimum=5, maximum=100, value=strategy_params["max_allocation_percentage"], step=5,
+                                            label="Maximum Allocation (%)")
+            
+            strategy_update_btn = gr.Button("Update Strategy Parameters")
+            strategy_message = gr.Textbox(label="Strategy Update Status")
+            
+            strategy_update_btn.click(update_strategy, 
+                                     inputs=[timeframe, max_allocation], 
+                                     outputs=strategy_message)
+            
+            gr.Markdown("---")
+            gr.Markdown("## Strategy Management")
+            
+            # Create a tabbed interface for strategy management
+            with gr.Tabs():
+                # Tab 1: Select Existing Strategy
+                with gr.TabItem("Select Strategy"):
+                    gr.Markdown("### Available Strategies")
+                    
+                    # Display saved strategies as a table
+                    saved_strategies = gr.Dataframe(
+                        headers=["ID", "Name", "Description"],
+                        datatype=["number", "str", "str"],
+                        label="Available Strategies"
+                    )
+                    
+                    refresh_strategies_btn = gr.Button("Refresh Strategies")
+                    
+                    def get_strategies_as_df():
+                        strategies = get_saved_strategies()
+                        if not strategies:
+                            return [[0, "No strategies found", "Create a new strategy first"]]
+                        return [[s["id"], s["name"], s["description"]] for s in strategies]
+                    
+                    refresh_strategies_btn.click(get_strategies_as_df, outputs=saved_strategies)
+                    
+                    # Create a dropdown for strategy selection instead of number input
+                    gr.Markdown("### Select a Strategy")
+                    
+                    def get_strategy_dropdown_choices():
+                        strategies = get_saved_strategies()
+                        if not strategies:
+                            return [("No strategies available", 0)]
+                        return [(f"{s['id']} - {s['name']}", s['id']) for s in strategies]
+                    
+                    strategy_dropdown = gr.Dropdown(
+                        choices=get_strategy_dropdown_choices(),
+                        label="Choose Strategy",
+                        value=None
+                    )
+                    
+                    # Connect refresh button to also update dropdown
+                    def refresh_all_strategy_displays():
+                        df = get_strategies_as_df()
+                        choices = get_strategy_dropdown_choices()
+                        return df, choices
+                    
+                    refresh_strategies_btn.click(
+                        refresh_all_strategy_displays,
+                        outputs=[saved_strategies, strategy_dropdown]
+                    )
+                    
+                    # Load, Delete buttons
+                    with gr.Row():
+                        load_btn = gr.Button("Load Selected Strategy", variant="primary")
+                        delete_btn = gr.Button("Delete Selected Strategy", variant="stop")
+                    
+                    # Add a status message
+                    strategy_action_message = gr.Textbox(label="Status", interactive=False)
+                    
+                    # Add strategy details display section
+                    gr.Markdown("### Selected Strategy Details")
+                    selected_strategy_view = gr.Markdown("No strategy selected")
+                    
+                    # Update load strategy function to work with dropdown
+                    def load_selected_strategy(strategy_dropdown_value):
+                        if not strategy_dropdown_value:
+                            return "Please select a strategy first", "No strategy selected"
+                        
+                        try:
+                            strategy_id = int(strategy_dropdown_value)
+                            strategy = get_strategy_by_id(strategy_id)
+                            
+                            if not strategy:
+                                return "Strategy not found", "Strategy not found"
+                            
+                            # Update global parameters
+                            global strategy_params
+                            strategy_params["strategy_text"] = strategy["strategy_text"]
+                            for key, value in strategy["parameters"].items():
+                                if key in strategy_params:
+                                    strategy_params[key] = value
+                            
+                            # Create a markdown view of the strategy - improved formatting
+                            view_text = f"""
+## {strategy['name']}
+
+**Description**: {strategy['description']}
+
+**Strategy Logic**:
+```
+{strategy['strategy_text']}
+```
+
+**Parameters**:
+- Timeframe: {strategy["parameters"].get("timeframe_minutes", "N/A")} minutes
+- Max Allocation: {strategy["parameters"].get("max_allocation_percentage", "N/A")}%
+"""
+                            
+                            # Return success message and view
+                            return f"Strategy '{strategy['name']}' loaded successfully", view_text
+                        except Exception as e:
+                            return f"Error loading strategy: {e}", "Error loading strategy"
+                    
+                    # Delete strategy function updated for dropdown
+                    def delete_selected_strategy(strategy_dropdown_value):
+                        if not strategy_dropdown_value:
+                            return "Please select a strategy first", get_strategy_dropdown_choices()
+                        
+                        try:
+                            strategy_id = int(strategy_dropdown_value)
+                            conn = sqlite3.connect(DB_PATH)
+                            cursor = conn.cursor()
+                            
+                            # Check if strategy exists
+                            cursor.execute("SELECT name FROM strategies WHERE id = ?", (strategy_id,))
+                            result = cursor.fetchone()
+                            
+                            if not result:
+                                conn.close()
+                                return "Strategy not found", get_strategy_dropdown_choices()
+                            
+                            strategy_name = result[0]
+                            
+                            # Delete the strategy
+                            cursor.execute("DELETE FROM strategies WHERE id = ?", (strategy_id,))
+                            conn.commit()
+                            conn.close()
+                            
+                            # Get updated choices
+                            new_choices = get_strategy_dropdown_choices()
+                            
+                            return f"Strategy '{strategy_name}' deleted successfully", new_choices
+                        except Exception as e:
+                            return f"Error deleting strategy: {e}", get_strategy_dropdown_choices()
+                    
+                    # Connect buttons to new functions
+                    load_btn.click(
+                        load_selected_strategy,
+                        inputs=[strategy_dropdown],
+                        outputs=[strategy_action_message, selected_strategy_view]
+                    )
+                    
+                    delete_btn.click(
+                        delete_selected_strategy,
+                        inputs=[strategy_dropdown],
+                        outputs=[strategy_action_message, strategy_dropdown]
+                    )
+                
+                # Tab 2: Create/Edit Strategy
+                with gr.TabItem("Create/Edit Strategy"):
+                    gr.Markdown("### Strategy Editor")
+                    
+                    # Strategy editor section
+                    strategy_name = gr.Textbox(label="Strategy Name", placeholder="Enter a name for your strategy")
+                    strategy_description = gr.Textbox(label="Strategy Description", placeholder="Enter a brief description of what your strategy does")
+                    
+                    # Add a checkbox to indicate if editing existing strategy
+                    is_editing = gr.Checkbox(label="Edit Existing Strategy", value=False)
+                    edit_id = gr.Number(label="Strategy ID to Edit", value=0, visible=False)
+                    
+                    # Add a dropdown to select strategy for editing
+                    edit_strategy_dropdown = gr.Dropdown(
+                        choices=get_strategy_dropdown_choices(),
+                        label="Choose Strategy to Edit",
+                        visible=False
+                    )
+                    
+                    gr.Markdown("### Strategy Logic")
+                    gr.Markdown("""Write your trading strategy using the available indicators. Be specific about entry and exit conditions.
+                    
+**Example Strategy:**
+```
+Buy when RSI is below 30 and the price is near the lower Bollinger Band (position < 0.2).
+Sell when RSI is above 70 and the price is near the upper Bollinger Band (position > 0.8).
+Increase confidence if the ADX shows a strong trend (> 25) in the same direction.
+Use 40% of available capital for trades if confidence is high (> 70), otherwise use 20%.
+```
+
+The strategy will be interpreted by AI to generate trading signals based on current market conditions.""")
+                    
+                    # Available indicators
+                    with gr.Accordion("View Available Indicators", open=False):
+                        indicators_info = gr.Markdown(get_available_indicators())
+                    
+                    # Strategy text editor - moved up before being referenced
+                    strategy_text = gr.TextArea(
+                        label="Strategy Logic", 
+                        placeholder="Enter your trading strategy logic here...", 
+                        value=strategy_params.get("strategy_text", ""), 
+                        lines=10,
+                        max_lines=20
+                    )
+                    
+                    # Connect checkbox to show/hide controls
+                    def toggle_edit_mode(is_editing):
+                        return {
+                            edit_strategy_dropdown: gr.update(visible=is_editing),
+                        }
+                    
+                    is_editing.change(
+                        toggle_edit_mode,
+                        inputs=[is_editing],
+                        outputs=[edit_strategy_dropdown]
+                    )
+                    
+                    # Function to load strategy into editor
+                    def load_strategy_to_editor(strategy_dropdown_value):
+                        if not strategy_dropdown_value:
+                            return "Please select a strategy to edit", "", "", "", 0
+                        
+                        try:
+                            strategy_id = int(strategy_dropdown_value)
+                            strategy = get_strategy_by_id(strategy_id)
+                            
+                            if not strategy:
+                                return "Strategy not found", "", "", "", 0
+                            
+                            return "Strategy loaded for editing", strategy["name"], strategy["description"], strategy["strategy_text"], strategy_id
+                        except Exception as e:
+                            return f"Error loading strategy: {e}", "", "", "", 0
+                    
+                    # Connect edit dropdown to load function
+                    edit_strategy_dropdown.change(
+                        load_strategy_to_editor,
+                        inputs=[edit_strategy_dropdown],
+                        outputs=[strategy_action_message, strategy_name, strategy_description, strategy_text, edit_id]
+                    )
+                    
+                    # Save button and status
+                    save_btn = gr.Button("Save Strategy", variant="primary")
+                    save_status = gr.Textbox(label="Save Status", interactive=False)
+                    
+                    # Enhanced save function
+                    def save_strategy_enhanced(is_editing, edit_id, name, description, text):
+                        try:
+                            if not name or not text:
+                                return "Error: Strategy name and logic are required", get_strategy_dropdown_choices(), get_strategy_dropdown_choices()
+                            
+                            # Get current strategy parameters
+                            parameters = strategy_params.copy()
+                            parameters["strategy_text"] = text
+                            
+                            conn = sqlite3.connect(DB_PATH)
+                            cursor = conn.cursor()
+                            
+                            strategy_id = int(edit_id) if is_editing and edit_id > 0 else 0
+                            
+                            if is_editing and strategy_id > 0:
+                                # Update existing strategy
+                                cursor.execute(
+                                    "UPDATE strategies SET name = ?, description = ?, strategy_text = ?, parameters = ? WHERE id = ?",
+                                    (name, description, text, json.dumps(parameters), strategy_id)
+                                )
+                                message = f"Strategy '{name}' updated successfully"
+                            else:
+                                # Create new strategy
+                                cursor.execute(
+                                    "INSERT INTO strategies (name, description, strategy_text, parameters) VALUES (?, ?, ?, ?)",
+                                    (name, description, text, json.dumps(parameters))
+                                )
+                                message = f"Strategy '{name}' saved successfully"
+                            
+                            conn.commit()
+                            conn.close()
+                            
+                            # Update dropdown choices
+                            new_choices = get_strategy_dropdown_choices()
+                            
+                            return message, new_choices, new_choices
+                        except Exception as e:
+                            return f"Error saving strategy: {e}", get_strategy_dropdown_choices(), get_strategy_dropdown_choices()
+                    
+                    # Connect save button
+                    save_btn.click(
+                        save_strategy_enhanced,
+                        inputs=[is_editing, edit_id, strategy_name, strategy_description, strategy_text],
+                        outputs=[save_status, strategy_dropdown, edit_strategy_dropdown]
+                    )
+                    
+                    # Clear form button
+                    clear_btn = gr.Button("Clear Form")
+                    
+                    def clear_form():
+                        return "", "", "", False, 0
+                    
+                    clear_btn.click(
+                        clear_form,
+                        outputs=[strategy_name, strategy_description, strategy_text, is_editing, edit_id]
+                    )
+            
+            gr.Markdown("---")
+            gr.Markdown("## Execute Analysis")
+            gr.Markdown("First select a strategy above, then run the analysis pipeline.")
+            
+            # Check if strategy is loaded - improved formatting
+            def check_strategy_loaded():
+                if not strategy_params.get("strategy_text"):
+                    return (
+                        "⚠️ No strategy selected! Please load a strategy first.",
+                        gr.update(interactive=False)
+                    )
+                else:
+                    # Format the strategy preview in a more structured way
+                    strategy_text = strategy_params.get("strategy_text", "")
+                    
+                    # Properly format the strategy preview
+                    strategy_preview = f"""
+## Current Strategy
+
+```
+{strategy_text}
+```
+
+**Parameters**:
+- Timeframe: {strategy_params.get('timeframe_minutes', 'N/A')} minutes
+- Max Allocation: {strategy_params.get('max_allocation_percentage', 'N/A')}%
+"""
+                    
+                    return (
+                        strategy_preview,
+                        gr.update(interactive=True)
+                    )
+            
+            # Display current strategy and run button
+            current_strategy_info = gr.Markdown("No strategy loaded")
+            run_pipeline_btn = gr.Button("Run Analysis Pipeline", variant="primary", interactive=False)
+            
+            # Add a refresh button to check if strategy is loaded
+            check_strategy_btn = gr.Button("Check Current Strategy")
+            check_strategy_btn.click(
+                check_strategy_loaded,
+                outputs=[current_strategy_info, run_pipeline_btn]
+            )
+            
+            # Run button should automatically check if strategy is loaded
+            analysis_result = gr.Markdown("Analysis results will appear here...")
+            
+            # Function to run full analysis and format detailed output
+            def run_full_analysis_with_check():
+                try:
+                    if not strategy_params.get("strategy_text"):
+                        return "Error: No strategy selected. Please load a strategy before running analysis."
+                    
+                    result = run_full_analysis()
+                    if "error" in result:
+                        return f"Analysis failed: {result['error']}"
+                    
+                    return format_detailed_analysis_results(result)
+                except Exception as e:
+                    return f"Error running analysis: {str(e)}"
+            
+            # Connect the run button
+            run_pipeline_btn.click(
+                run_full_analysis_with_check,
+                outputs=[analysis_result]
+            )
+        
+        # Trading Tab
+        with gr.TabItem("Trading"):
+            gr.Markdown("## Account Summary")
+            
+            account_summary = gr.Markdown("")
+            
+            with gr.Row():
+                refresh_account_btn = gr.Button("Refresh Account Info")
+                reset_portfolio_btn = gr.Button("Reset Portfolio")
+            
+            reset_portfolio_message = gr.Textbox(label="Reset Portfolio Status")
+            
+            refresh_account_btn.click(get_account_summary, outputs=account_summary)
+            reset_portfolio_btn.click(reset_portfolio, outputs=reset_portfolio_message)
+            
+            gr.Markdown("## Manual Trading")
+            
+            with gr.Row():
+                action = gr.Dropdown(["buy", "sell", "check"], label="Action")
+                symbol = gr.Dropdown(["BTC/USD", "ETH/USD"], label="Symbol", value="BTC/USD")
+                allocation = gr.Slider(minimum=1, maximum=100, value=10, label="Allocation Percentage")
+            
+            execute_btn = gr.Button("Execute Trade")
+            trade_result = gr.Textbox(label="Trade Result")
+            
+            execute_btn.click(execute_trade, inputs=[action, symbol, allocation], outputs=trade_result)
+        
+        # Monitoring Tab
+        with gr.TabItem("Monitoring"):
+            with gr.Tabs():
+                with gr.TabItem("Analysis Results"):
+                    gr.Markdown("## Latest Analysis Results")
+                    
+                    analysis_history = gr.Dataframe(
+                        headers=["ID", "Timestamp", "Strategy", "Signal", "Confidence", "Allocation"],
+                        datatype=["number", "str", "str", "str", "number", "number"],
+                        label="Recent Analysis Results"
+                    )
+                    
+                    def get_analysis_history():
+                        results = get_recent_analysis_results(10)
+                        return [
+                            [r["id"], r["timestamp"], r["strategy_name"], r["signal"].upper(), 
+                             r["confidence"], r["allocation_percentage"]]
+                            for r in results
+                        ]
+                    
+                    refresh_analysis_btn = gr.Button("Refresh Results")
+                    refresh_analysis_btn.click(get_analysis_history, outputs=analysis_history)
+                    
+                    selected_analysis_id = gr.Number(label="Result ID to View", value=0)
+                    view_analysis_btn = gr.Button("View Detailed Analysis")
+                    
+                    detailed_analysis = gr.Markdown("Select an analysis result and click 'View Detailed Analysis'")
+                    
+                    def view_detailed_analysis(analysis_id):
+                        if analysis_id <= 0:
+                            return "Please select a valid analysis result ID"
+                        
+                        try:
+                            conn = sqlite3.connect(DB_PATH)
+                            cursor = conn.cursor()
+                            
+                            # Get the full analysis result
+                            cursor.execute("""
+                                SELECT ar.*, s.name as strategy_name
+                                FROM analysis_results ar
+                                LEFT JOIN strategies s ON ar.strategy_id = s.id
+                                WHERE ar.id = ?
+                            """, (int(analysis_id),))
+                            
+                            row = cursor.fetchone()
+                            conn.close()
+                            
+                            if not row:
+                                return "Analysis result not found"
+                            
+                            # Convert row to dict
+                            column_names = [description[0] for description in cursor.description]
+                            result = {column_names[i]: row[i] for i in range(len(column_names))}
+                            
+                            # Parse JSON fields
+                            if "indicator_values" in result and result["indicator_values"]:
+                                try:
+                                    result["technical_indicators"] = json.loads(result["indicator_values"])
+                                except json.JSONDecodeError as e:
+                                    result["technical_indicators"] = {"error": f"Failed to parse indicators: {str(e)}"}
+                            
+                            # Format the detailed result
+                            return format_detailed_analysis_results(result)
+                        except Exception as e:
+                            import traceback
+                            return f"Error retrieving analysis details: {str(e)}\n{traceback.format_exc()}"
+                    
+                    view_analysis_btn.click(view_detailed_analysis, inputs=[selected_analysis_id], outputs=detailed_analysis)
+                
+                with gr.TabItem("Positions"):
+                    gr.Markdown("## Active Positions")
+                    
+                    positions_display = gr.Markdown("")
+                    refresh_positions_btn = gr.Button("Refresh Positions")
+                    
+                    refresh_positions_btn.click(format_active_positions, outputs=positions_display)
+                
+                with gr.TabItem("Transactions"):
+                    gr.Markdown("## Transaction History")
+                    
+                    transactions_history = gr.Dataframe(
+                        headers=["ID", "Date", "Symbol", "Action", "Quantity", "Price", "Status"],
+                        datatype=["number", "str", "str", "str", "number", "number", "str"],
+                        label="Recent Transactions"
+                    )
+                    
+                    def get_transactions_history():
+                        txs = get_recent_transactions(20)
+                        return [
+                            [tx["id"], tx["timestamp"], tx["symbol"], tx["action"].upper(), 
+                             float(tx["quantity"]), float(tx["price"]), tx["status"]]
+                            for tx in txs
+                        ]
+                    
+                    refresh_tx_btn = gr.Button("Refresh Transactions")
+                    refresh_tx_btn.click(get_transactions_history, outputs=transactions_history)
+                    
+                    orders_display = gr.Markdown("")
+                    refresh_orders_btn = gr.Button("Show Full Transaction Details")
+                    
+                    refresh_orders_btn.click(format_order_history, outputs=orders_display)
+        
+        # Automated Analysis Tab
+        with gr.TabItem("Automated Analysis"):
+            gr.Markdown("## Background Analysis")
+            
+            gr.Markdown("""
+            ### Full Crew Automated Analysis
+            
+            The automated analysis will run the complete Bitcoin Analysis Crew at intervals defined by the timeframe setting.
+            This includes:
+            - Technical analysis
+            - Market sentiment analysis
+            - Order execution
+            
+            **All trades and analysis results will be logged** to a file in the data directory for later review.
+            """)
+            
+            gr.Markdown(f"Current timeframe: **{strategy_params['timeframe_minutes']} minutes**")
+            
+            with gr.Row():
+                start_btn = gr.Button("Start Automated Analysis", variant="primary")
+                stop_btn = gr.Button("Stop Automated Analysis", variant="stop")
+            
+            auto_status = gr.Textbox(label="Automation Status")
+            
+            start_btn.click(start_background_process, outputs=auto_status)
+            stop_btn.click(stop_background_process, outputs=auto_status)
+            
+            # Add log path information
+            log_path_info = gr.Markdown(f"""
+            **Log File Location**
+            
+            Trading logs will be saved to:
+            ```
+            {os.path.dirname(DB_PATH)}
+            ```
+            A new log file is created for each trading session with format: `auto_trading_log_YYYYMMDD_HHMMSS.txt`
+            
+            These logs contain:
+            - All analysis results
+            - Trade executions
+            - Account balances
+            - Profit/loss tracking
+            - Errors and warnings
+            """)
+            
+            auto_result = gr.Markdown("Automated analysis results will appear here...")
+            
+            # Refresh button with detailed results
+            auto_refresh = gr.Button("Refresh Latest Results")
+            
+            # Update to use detailed formatting
+            auto_refresh.click(format_detailed_analysis_results, outputs=auto_result)
+            
+            # Add warning about strategy selection
+            gr.Markdown("""
+            **IMPORTANT**: Make sure you have loaded a strategy from the Strategy Configuration tab before starting automated analysis.
+            The system will use the currently loaded strategy for all automated runs.
+            """)
+            
+            # Add instructions for running for days
+            gr.Markdown("""
+            ### Running for Extended Periods
+            
+            To run this application continuously for days:
+            
+            1. Start the automated analysis with your chosen strategy and timeframe
+            2. Keep this application running (do not close the browser tab or terminal)
+            3. If running on a remote server, use tools like `screen` or `tmux` to keep the session alive
+            
+            **Example terminal command for persistent session**:
+            ```
+            # Start a new screen session
+            screen -S cryptic_trading
+            
+            # Then run your application in that session
+            python src/ui/app.py
+            
+            # You can detach from the session with Ctrl+A, D and reconnect later with:
+            screen -r cryptic_trading
+            ```
+            """)
+
+# Launch the app
+if __name__ == "__main__":
+    # Ensure directories exist
+    os.makedirs("results", exist_ok=True)
+    
+    # Run initial data fetching
+    fetch_account_info()
+    fetch_order_history()
+    fetch_active_positions()
+    
+    # Launch the app
+    app.launch(share=False) 

test_crew.py

@@ -0,0 +1,14 @@
+from src.crypto_analysis.crew import BitcoinAnalysisCrew
+
+# Create the crew with custom timeframe and max_allocation
+crew = BitcoinAnalysisCrew(timeframe='15m', max_allocation=50)
+
+try:
+    # Run analysis
+    print("Starting analysis...")
+    result = crew.run_analysis()
+    print(f"Analysis completed with signal: {result.get('signal')}, "
+          f"confidence: {result.get('confidence')}%, "
+          f"allocation: {result.get('allocation_percentage')}%")
+except Exception as e:
+    print(f"Error during analysis: {str(e)}") 

tests/run_tests.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+# Run all tests for the CrypticAI project
+
+# Change to the project root directory
+cd "$(dirname "$0")/.." || exit
+
+# Setup
+echo "========================================"
+echo "Setting up environment..."
+echo "========================================"
+source venv/bin/activate || { echo "Failed to activate virtual environment. Make sure venv exists."; exit 1; }
+
+# Run tools tests
+echo -e "\n========================================"
+echo "Running comprehensive tool tests..."
+echo "========================================"
+python tests/test_all_tools.py
+
+# Run individual component tests
+echo -e "\n========================================"
+echo "Running Bitcoin Data Tool tests..."
+echo "========================================"
+python tests/test_bitcoin.py
+
+echo -e "\n========================================"
+echo "Running Bitcoin News Tool tests..."
+echo "========================================"
+python tests/test_bitcoin_news.py
+
+echo -e "\n========================================"
+echo "Running Yahoo Finance Tools tests..."
+echo "========================================"
+python tests/test_yahoo_tools.py
+
+echo -e "\n========================================"
+echo "All tests completed!"
+echo "========================================" 

tests/test_all_tools.py

@@ -0,0 +1,147 @@
+"""
+Test script to verify that tools can be initialized properly.
+This is helpful for checking API keys and connections.
+"""
+
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+from src.crypto_analysis.tools import (
+    AlpacaBitcoinDataTool,
+    TechnicalIndicatorsTool,
+    BitcoinNewsTool,
+    BitcoinSentimentTool,
+    YahooBitcoinDataTool,
+    YahooCryptoMarketTool
+)
+
+def test_alpaca_tools():
+    """Test Alpaca tools initialization and basic functionality"""
+    print("Testing Alpaca Bitcoin Data Tool...")
+    
+    # Check if API keys are set
+    api_key = os.getenv("ALPACA_API_KEY")
+    api_secret = os.getenv("ALPACA_API_SECRET")
+    
+    if not api_key or not api_secret:
+        print("⚠️ Alpaca API keys not found in environment variables")
+        return
+    
+    try:
+        # Initialize the tool
+        tool = AlpacaBitcoinDataTool()
+        print("✓ Tool initialized successfully")
+        
+        # Test a simple data fetch
+        print("Fetching data (this might take a few seconds)...")
+        result = tool._run(timeframe="5Min", days_back=1)
+        
+        if "error" in result:
+            print(f"⚠️ Error: {result['error']}")
+        else:
+            print(f"✓ Successfully retrieved {len(result.get('dataframe', []))} data points")
+            print(f"✓ Last Bitcoin price: ${result.get('last_price', 'N/A')}")
+    
+    except Exception as e:
+        print(f"⚠️ Exception occurred: {e}")
+
+def test_technical_indicators():
+    """Test technical indicators tool"""
+    print("\nTesting Technical Indicators Tool...")
+    
+    try:
+        # Initialize the tool
+        tool = TechnicalIndicatorsTool()
+        print("✓ Tool initialized successfully")
+        
+        # Test indicators calculation
+        print("Calculating indicators (this might take a few seconds)...")
+        result = tool._run(timeframe="5Min", days_back=1)
+        
+        if "error" in result:
+            print(f"⚠️ Error: {result['error']}")
+        else:
+            print(f"✓ Successfully calculated technical indicators")
+            print(f"✓ Current RSI: {result.get('indicators', {}).get('rsi', 'N/A')}")
+            print(f"✓ Current ADX: {result.get('indicators', {}).get('adx', 'N/A')}")
+            print(f"✓ Buy signal: {result.get('signals', {}).get('buy_signal', 'N/A')}")
+            print(f"✓ Sell signal: {result.get('signals', {}).get('sell_signal', 'N/A')}")
+    
+    except Exception as e:
+        print(f"⚠️ Exception occurred: {e}")
+
+def test_news_tools():
+    """Test news tools initialization and basic functionality using Tavily"""
+    print("\nTesting Bitcoin News Tool with Tavily...")
+    
+    # Check if API key is set
+    api_key = os.getenv("TAVILY_API_KEY")
+    
+    if not api_key:
+        print("⚠️ Tavily API key not found in environment variables")
+        print("Will try to fetch news using web search as fallback")
+    
+    try:
+        # Initialize the tool
+        tool = BitcoinNewsTool()
+        print("✓ Tool initialized successfully")
+        
+        # Test news fetch
+        print("Fetching news (this might take a few seconds)...")
+        result = tool._run(days_back=1, limit=3)
+        
+        if "error" in result:
+            print(f"⚠️ Error: {result['error']}")
+        else:
+            articles = result.get("articles", [])
+            print(f"✓ Successfully retrieved {len(articles)} news articles")
+            
+            # Print article titles
+            for i, article in enumerate(articles, 1):
+                print(f"  {i}. {article.get('title', 'No title')}")
+    
+    except Exception as e:
+        print(f"⚠️ Exception occurred: {e}")
+
+def test_yahoo_tools():
+    """Test Yahoo Finance tools"""
+    print("\nTesting Yahoo Finance Bitcoin Data Tool...")
+    
+    try:
+        # Initialize the tool
+        tool = YahooBitcoinDataTool()
+        print("✓ Tool initialized successfully")
+        
+        # Test data fetch
+        print("Fetching data (this might take a few seconds)...")
+        result = tool._run(period="1d", interval="1h")
+        
+        if "error" in result:
+            print(f"⚠️ Error: {result['error']}")
+        else:
+            print(f"✓ Successfully retrieved Bitcoin data from Yahoo Finance")
+            print(f"✓ Last price: ${result.get('last_price', 'N/A')}")
+            
+            # Print metadata
+            metadata = result.get("metadata", {})
+            print(f"✓ Market cap: {metadata.get('market_cap', 'N/A')}")
+            print(f"✓ 24h volume: {metadata.get('volume_24h', 'N/A')}")
+    
+    except Exception as e:
+        print(f"⚠️ Exception occurred: {e}")
+
+if __name__ == "__main__":
+    print("=" * 50)
+    print("TESTING BITCOIN ANALYSIS TOOLS")
+    print("=" * 50)
+    
+    # Test each tool category
+    test_yahoo_tools()  # Start with Yahoo as it doesn't require API keys
+    test_alpaca_tools()
+    test_news_tools()
+    test_technical_indicators()
+    
+    print("\n" + "=" * 50)
+    print("TESTING COMPLETE")
+    print("=" * 50) 

tests/test_bitcoin.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""
+Simple test script for Bitcoin analysis
+"""
+
+import os
+import sys
+import json
+from dotenv import load_dotenv
+
+# Add the project root to the Python path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Load environment variables
+load_dotenv()
+
+# Check required API keys
+openai_key = os.getenv("OPENAI_API_KEY")
+if not openai_key:
+    print("Error: OPENAI_API_KEY not found in environment variables")
+    sys.exit(1)
+
+print("Testing Bitcoin tools...")
+
+# Test Yahoo Bitcoin Data Tool
+try:
+    from src.crypto_analysis.tools.bitcoin_tools import YahooBitcoinDataTool
+    
+    print("\nTesting Yahoo Bitcoin Data Tool...")
+    bitcoin_data_tool = YahooBitcoinDataTool()
+    data = bitcoin_data_tool._run(period="1mo", interval="1d")
+    
+    if "error" in data:
+        print(f"❌ Error: {data['error']}")
+    else:
+        print(f"✅ Successfully retrieved Bitcoin data")
+        print(f"📊 Current price: ${data['price']:.2f}")
+        print(f"📈 Trend: {data['trend']} ({data['percent_change']:.2f}%)")
+        print(f"💰 Market cap: {data['market_cap']}")
+except Exception as e:
+    print(f"❌ Error testing Bitcoin Data Tool: {str(e)}")
+
+# Test Bitcoin News Tool
+try:
+    from src.crypto_analysis.tools.bitcoin_tools import BitcoinNewsTool
+    
+    print("\nTesting Bitcoin News Tool...")
+    bitcoin_news_tool = BitcoinNewsTool()
+    news = bitcoin_news_tool._run()
+    
+    if news and "articles" in news and len(news["articles"]) > 0:
+        print(f"✅ Successfully retrieved Bitcoin news")
+        for i, article in enumerate(news["articles"]):
+            print(f"📰 Article {i+1}: {article['title']}")
+    else:
+        print("❌ No news articles found")
+except Exception as e:
+    print(f"❌ Error testing Bitcoin News Tool: {str(e)}")
+
+# Test Bitcoin Analysis Crew
+try:
+    from src.crypto_analysis.crew import BitcoinAnalysisCrew
+    
+    print("\nTesting Bitcoin Analysis Crew...")
+    print("This may take a minute or two as it needs to query the LLM...")
+    
+    crew = BitcoinAnalysisCrew()
+    result = crew.run_analysis()
+    
+    print("\nAnalysis Results:")
+    # Don't try to JSON serialize the entire result
+    print(f"Signal: {result.get('signal', 'unknown')}")
+    print(f"Confidence: {result.get('confidence', 0)}%")
+    print(f"Reasoning: {result.get('reasoning', 'No reasoning provided')}")
+    
+    print(f"\n✅ Analysis complete!")
+    print(f"🔍 Recommendation: {result.get('signal', 'unknown').upper()}")
+    print(f"🎯 Confidence: {result.get('confidence', 0)}%")
+    
+except Exception as e:
+    print(f"❌ Error testing Bitcoin Analysis Crew: {str(e)}")
+
+print("\nAll tests completed!") 

tests/test_bitcoin_news.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""
+Test script for the RealBitcoinNewsTool
+"""
+
+import json
+from src.crypto_analysis.tools.bitcoin_tools import RealBitcoinNewsTool, YahooBitcoinDataTool
+
+def main():
+    """Test the Bitcoin news tool"""
+    print("===== Bitcoin Data Tool Test =====")
+    price_tool = YahooBitcoinDataTool()
+    price_data = price_tool._run()
+    print(f"Bitcoin Price: ${price_data.get('price', 'N/A')}")
+    print(f"Market Cap: ${price_data.get('market_cap', 'N/A')}")
+    print(f"Percent Change: {price_data.get('percent_change', 'N/A')}%")
+    print(f"Trend: {price_data.get('trend', 'N/A')}")
+    print()
+    
+    print("===== Bitcoin News Tool Test =====")
+    news_tool = RealBitcoinNewsTool()
+    
+    print("\nTesting with source=None (should try multiple sources):")
+    news_data = news_tool._run(count=3)
+    print(f"Found {news_data.get('count', 0)} articles")
+    
+    # Print each article
+    for i, article in enumerate(news_data.get('articles', []), 1):
+        print(f"\nArticle {i}:")
+        print(f"Title: {article.get('title', 'N/A')}")
+        print(f"Source: {article.get('source', 'N/A')}")
+        print(f"URL: {article.get('url', 'N/A')}")
+        description = article.get('description', 'N/A')
+        print(f"Description: {description[:100]}..." if len(description) > 100 else f"Description: {description}")
+    
+    # Now try with a specific source
+    print("\nTesting with source='coindesk':")
+    news_data = news_tool._run(source='coindesk', count=2)
+    print(f"Found {news_data.get('count', 0)} articles from CoinDesk")
+    
+    # Print each article
+    for i, article in enumerate(news_data.get('articles', []), 1):
+        print(f"\nArticle {i}:")
+        print(f"Title: {article.get('title', 'N/A')}")
+        print(f"Source: {article.get('source', 'N/A')}")
+        print(f"URL: {article.get('url', 'N/A')}")
+        description = article.get('description', 'N/A')
+        print(f"Description: {description[:100]}..." if len(description) > 100 else f"Description: {description}")
+
+if __name__ == "__main__":
+    main() 

tests/test_yahoo_tools.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""
+Test script for the Yahoo Finance crypto tools
+"""
+
+import os
+import sys
+import json
+from dotenv import load_dotenv
+
+# Add the project root to the Python path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Load environment variables
+load_dotenv()
+
+def main():
+    """Test the Yahoo Finance crypto tools"""
+    # Test Yahoo Bitcoin Data Tool
+    try:
+        from src.crypto_analysis.tools.yahoo_tools import YahooBitcoinDataTool
+        
+        print("\n===== Yahoo Bitcoin Data Tool Test =====")
+        bitcoin_data_tool = YahooBitcoinDataTool()
+        data = bitcoin_data_tool._run(period="1d", interval="1h")
+        
+        if "error" in data:
+            print(f"❌ Error: {data['error']}")
+        else:
+            print(f"✅ Successfully retrieved Bitcoin data from Yahoo Finance")
+            print(f"📊 Current price: ${data.get('last_price', 'N/A')}")
+            print(f"💰 Market cap: {data.get('metadata', {}).get('market_cap', 'N/A')}")
+            print(f"📈 Time period: {data.get('time_period', 'N/A')}")
+            print(f"⏱️ Interval: {data.get('interval', 'N/A')}")
+    except Exception as e:
+        print(f"❌ Error testing Yahoo Bitcoin Data Tool: {str(e)}")
+
+    # Test Yahoo Crypto Market Tool
+    try:
+        from src.crypto_analysis.tools.yahoo_tools import YahooCryptoMarketTool
+        
+        print("\n===== Yahoo Crypto Market Tool Test =====")
+        crypto_market_tool = YahooCryptoMarketTool()
+        market_data = crypto_market_tool._run(top_n=5)
+        
+        if "error" in market_data:
+            print(f"❌ Error: {market_data['error']}")
+        else:
+            print(f"✅ Successfully retrieved crypto market data")
+            
+            # Market summary
+            summary = market_data.get('market_summary', {})
+            print(f"📊 Total market cap: ${summary.get('total_market_cap', 'N/A')}")
+            print(f"🔶 BTC dominance: {summary.get('btc_dominance', 'N/A'):.2f}%")
+            print(f"📈 Market trend: {summary.get('market_trend', 'N/A')}")
+            
+            # Top cryptocurrencies
+            cryptos = market_data.get('cryptocurrencies', [])
+            print(f"\n📋 Top {len(cryptos)} cryptocurrencies:")
+            
+            for i, crypto in enumerate(cryptos, 1):
+                print(f"\n{i}. {crypto.get('name', crypto.get('ticker', 'Unknown'))}:")
+                print(f"   Current price: ${crypto.get('current_price', 'N/A')}")
+                print(f"   Market cap: ${crypto.get('market_cap', 'N/A')}")
+                print(f"   24h change: {crypto.get('day_change_percent', 'N/A'):.2f}%")
+                print(f"   7d change: {crypto.get('week_change_percent', 'N/A'):.2f}%")
+    except Exception as e:
+        print(f"❌ Error testing Yahoo Crypto Market Tool: {str(e)}")
+
+if __name__ == "__main__":
+    main()