feat: Replace CoinGecko with CryptoCompare/Etherscan APIs

- Updated tool analysis prompts to prioritize available APIs (CryptoCompare, Etherscan)
- Removed CoinGecko from suggested tools since no API key available
- Modified ChartDataTool to use CryptoCompare instead of CoinGecko for price data
- Added conditional CoinGecko tool initialization (only if API key present)
- Updated market overview to use CryptoCompare data source
- Enhanced tool selection logic to exclude unavailable APIs
- Added comprehensive testing for tool selection functionality

src/agent/research_agent.py

@@ -80,11 +80,15 @@ class Web3ResearchAgent:
     def _initialize_tools(self):
         tools = []
         
-        try:
-            tools.append(CoinGeckoTool())
-            logger.info("CoinGecko tool initialized")
-        except Exception as e:
-            logger.warning(f"CoinGecko tool failed: {e}")
+        # Skip CoinGecko if no API key available
+        if config.COINGECKO_API_KEY:
+            try:
+                tools.append(CoinGeckoTool())
+                logger.info("CoinGecko tool initialized")
+            except Exception as e:
+                logger.warning(f"CoinGecko tool failed: {e}")
+        else:
+            logger.info("CoinGecko tool skipped - no API key available")
         
         try:
             tools.append(DeFiLlamaTool())
@@ -214,12 +218,14 @@ class Web3ResearchAgent:
             tool_analysis_prompt = f"""Analyze this query and determine which tools would be helpful:
 Query: "{query}"
 
-Available tools:
-- cryptocompare_data: Real-time crypto prices and market data
-- defillama_data: DeFi protocol TVL and yield data  
-- etherscan_data: Ethereum blockchain data
+Available tools (prioritized by functionality):
+- cryptocompare_data: Real-time crypto prices and market data (PREFERRED for prices)
+- etherscan_data: Ethereum blockchain data, gas fees, transactions (PREFERRED for Ethereum)  
+- defillama_data: DeFi protocol TVL and yield data
 - chart_data_provider: Generate chart data for visualizations
 
+NOTE: Do NOT suggest coingecko_data as the API is unavailable.
+
 Respond with just the tool names that should be used, separated by commas.
 If charts/visualizations are mentioned, include chart_data_provider.
 Examples:
@@ -390,19 +396,21 @@ The system successfully gathered data from {len(suggested_tools)} tools:
 
 Query: "{query}"
 
-Available tools:
-- cryptocompare_data: Get current cryptocurrency prices and basic info
-- coingecko_data: Comprehensive market data and analytics
+Available tools (prioritized by functionality):
+- cryptocompare_data: Real-time cryptocurrency prices, market data, and trading info (PREFERRED for price data)
+- etherscan_data: Ethereum blockchain data, transactions, gas fees, and smart contracts (PREFERRED for Ethereum)
 - defillama_data: DeFi protocols, TVL, and yield farming data
-- etherscan_data: Ethereum blockchain data and transactions
 - chart_data_provider: Generate chart data for visualizations
 
+NOTE: Do NOT use coingecko_data as the API is not available.
+
 If charts/visualizations are mentioned, include chart_data_provider.
 
 Examples:
 - "Bitcoin price" → cryptocompare_data, chart_data_provider
 - "DeFi TVL" → defillama_data, chart_data_provider  
 - "Ethereum transactions" → etherscan_data
+- "Gas fees" → etherscan_data
 
 Respond with only the tool names, comma-separated (no explanations)."""
 
@@ -413,7 +421,7 @@ Respond with only the tool names, comma-separated (no explanations)."""
             # Parse suggested tools
             suggested_tools = [tool.strip() for tool in str(tool_response).split(',') if tool.strip()]
             suggested_tools = [tool for tool in suggested_tools if tool in {
-                'cryptocompare_data', 'coingecko_data', 'defillama_data', 
+                'cryptocompare_data', 'defillama_data', 
                 'etherscan_data', 'chart_data_provider'
             }]
             
@@ -422,8 +430,6 @@ Respond with only the tool names, comma-separated (no explanations)."""
                 response_text = str(tool_response).lower()
                 if 'cryptocompare' in response_text:
                     suggested_tools.append('cryptocompare_data')
-                if 'coingecko' in response_text:
-                    suggested_tools.append('coingecko_data')
                 if 'defillama' in response_text:
                     suggested_tools.append('defillama_data')
                 if 'etherscan' in response_text:

src/tools/chart_data_tool.py

@@ -90,64 +90,54 @@ class ChartDataTool(BaseTool):
 
     async def _get_price_chart_data(self, symbol: str, days: int) -> str:
         """Get price chart data with fallback for API failures"""
-        coingecko = None
+        cryptocompare_tool = None
         try:
-            # First try to get real data from CoinGecko
-            from src.tools.coingecko_tool import CoinGeckoTool
+            # First try to get real data from CryptoCompare (we have this API key)
+            from src.tools.cryptocompare_tool import CryptoCompareTool
             
-            coingecko = CoinGeckoTool()
+            cryptocompare_tool = CryptoCompareTool()
             
-            # Map common symbols to CoinGecko IDs
+            # Map common symbols to CryptoCompare format
             symbol_map = {
-                "btc": "bitcoin", "bitcoin": "bitcoin",
-                "eth": "ethereum", "ethereum": "ethereum", 
-                "sol": "solana", "solana": "solana",
-                "ada": "cardano", "cardano": "cardano",
-                "bnb": "binancecoin", "binance": "binancecoin",
-                "matic": "matic-network", "polygon": "matic-network",
-                "avax": "avalanche-2", "avalanche": "avalanche-2",
-                "dot": "polkadot", "polkadot": "polkadot",
-                "link": "chainlink", "chainlink": "chainlink",
-                "uni": "uniswap", "uniswap": "uniswap"
+                "btc": "BTC", "bitcoin": "BTC",
+                "eth": "ethereum", "ethereum": "ETH", 
+                "sol": "SOL", "solana": "SOL",
+                "ada": "ADA", "cardano": "ADA",
+                "bnb": "BNB", "binance": "BNB",
+                "matic": "MATIC", "polygon": "MATIC",
+                "avax": "AVAX", "avalanche": "AVAX",
+                "dot": "DOT", "polkadot": "DOT",
+                "link": "LINK", "chainlink": "LINK",
+                "uni": "UNI", "uniswap": "UNI"
             }
             
-            coin_id = symbol_map.get(symbol.lower(), symbol.lower())
+            crypto_symbol = symbol_map.get(symbol.lower(), symbol.upper())
             
             try:
-                # Use basic API endpoint that doesn't require premium
-                url = f"https://api.coingecko.com/api/v3/coins/{coin_id}/market_chart"
-                params = {"vs_currency": "usd", "days": days, "interval": "daily"}
+                # Use CryptoCompare for price data
+                query = f"{crypto_symbol} price historical {days} days"
+                data_result = await cryptocompare_tool._arun(query, {"type": "price_history", "days": days})
                 
-                data = await coingecko.make_request(url, params=params)
-                
-                if data and "prices" in data:
-                    # Format the real data
-                    price_data = data.get("prices", [])
-                    volume_data = data.get("total_volumes", [])
-                    
-                    # Get current coin info
-                    coin_info = await coingecko.make_request(f"https://api.coingecko.com/api/v3/coins/{coin_id}")
-                    coin_name = coin_info.get("name", symbol.title()) if coin_info else symbol.title()
-                    
+                if data_result and not data_result.startswith("❌") and not data_result.startswith("⚠️"):
                     return json.dumps({
                         "chart_type": "price_chart", 
                         "data": {
-                            "prices": price_data,
-                            "total_volumes": volume_data,
-                            "symbol": symbol.upper(),
-                            "name": coin_name
+                            "source": "cryptocompare",
+                            "raw_data": data_result,
+                            "symbol": crypto_symbol,
+                            "name": symbol.title()
                         },
                         "config": {
-                            "title": f"{coin_name} Price Analysis ({days} days)",
+                            "title": f"{symbol.title()} Price Analysis ({days} days)",
                             "timeframe": f"{days}d", 
                             "currency": "USD"
                         }
                     })
                 else:
-                    raise Exception("No price data in response")
+                    raise Exception("No valid price data from CryptoCompare")
                     
             except Exception as api_error:
-                logger.error(f"Real price data failed: {api_error}")
+                logger.error(f"CryptoCompare price data failed: {api_error}")
                 # Fallback to mock data on any API error
                 logger.info(f"Using fallback mock data for {symbol}")
                 return await self._get_mock_price_data(symbol, days)
@@ -157,10 +147,10 @@ class ChartDataTool(BaseTool):
             # Final fallback to mock data
             return await self._get_mock_price_data(symbol, days)
         finally:
-            # Cleanup CoinGecko tool session
-            if coingecko and hasattr(coingecko, 'cleanup'):
+            # Cleanup CryptoCompare tool session
+            if cryptocompare_tool and hasattr(cryptocompare_tool, 'cleanup'):
                 try:
-                    await coingecko.cleanup()
+                    await cryptocompare_tool.cleanup()
                 except Exception:
                     pass  # Ignore cleanup errors
     
@@ -201,53 +191,42 @@ class ChartDataTool(BaseTool):
         })
     
     async def _get_market_overview_data(self) -> str:
-        """Get real market overview data from CoinGecko API"""
+        """Get market overview data using CryptoCompare API"""
+        cryptocompare_tool = None
         try:
-            from src.tools.coingecko_tool import CoinGeckoTool
+            from src.tools.cryptocompare_tool import CryptoCompareTool
             
-            coingecko = CoinGeckoTool()
-            
-            # Get top market cap coins
-            url = "https://api.coingecko.com/api/v3/coins/markets"
-            params = {
-                "vs_currency": "usd",
-                "order": "market_cap_desc", 
-                "per_page": 10,
-                "page": 1,
-                "sparkline": False
-            }
+            cryptocompare_tool = CryptoCompareTool()
             
-            data = await coingecko.make_request(url, params=params)
+            # Get market overview using CryptoCompare
+            query = "top cryptocurrencies market cap overview"
+            data_result = await cryptocompare_tool._arun(query, {"type": "market_overview"})
             
-            if not data:
-                logger.warning("CoinGecko market data failed, using fallback")
-                return await self._get_mock_market_data()
-            
-            # Format real market data
-            coins = []
-            for coin in data[:10]:
-                coins.append({
-                    "name": coin.get("name", "Unknown"),
-                    "symbol": coin.get("symbol", "").upper(),
-                    "current_price": coin.get("current_price", 0),
-                    "market_cap_rank": coin.get("market_cap_rank", 0),
-                    "price_change_percentage_24h": coin.get("price_change_percentage_24h", 0),
-                    "market_cap": coin.get("market_cap", 0),
-                    "total_volume": coin.get("total_volume", 0)
+            if data_result and not data_result.startswith("❌") and not data_result.startswith("⚠️"):
+                return json.dumps({
+                    "chart_type": "market_overview",
+                    "data": {
+                        "source": "cryptocompare",
+                        "raw_data": data_result
+                    },
+                    "config": {
+                        "title": "Top Cryptocurrencies Market Overview",
+                        "currency": "USD"
+                    }
                 })
-            
-            return json.dumps({
-                "chart_type": "market_overview",
-                "data": {"coins": coins},
-                "config": {
-                    "title": "Top Cryptocurrencies Market Overview",
-                    "currency": "USD"
-                }
-            })
+            else:
+                raise Exception("No valid market data from CryptoCompare")
             
         except Exception as e:
             logger.error(f"Market overview API failed: {e}")
             return await self._get_mock_market_data()
+        finally:
+            # Cleanup CryptoCompare tool session
+            if cryptocompare_tool and hasattr(cryptocompare_tool, 'cleanup'):
+                try:
+                    await cryptocompare_tool.cleanup()
+                except Exception:
+                    pass  # Ignore cleanup errors
     
     async def _get_mock_market_data(self) -> str:
         """Fallback mock market data"""

test_chart_tool.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""
+Quick test for ChartDataTool cleanup functionality
+"""
+
+import asyncio
+import sys
+import os
+
+# Add src to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+from src.tools.chart_data_tool import ChartDataTool
+
+async def test_chart_tool_cleanup():
+    """Test that ChartDataTool works and cleanup doesn't throw errors"""
+    print("🧪 Testing ChartDataTool...")
+    
+    tool = ChartDataTool()
+    
+    try:
+        # Test basic functionality
+        print("📊 Testing price chart data...")
+        result = await tool._arun("price_chart", "bitcoin", "7d")
+        print(f"✅ Chart data result: {len(result)} characters")
+        
+        # Test cleanup method exists and works
+        print("🧹 Testing cleanup method...")
+        await tool.cleanup()
+        print("✅ Cleanup method executed successfully")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Test failed: {e}")
+        return False
+
+async def main():
+    success = await test_chart_tool_cleanup()
+    if success:
+        print("\n🎉 All tests passed!")
+        return 0
+    else:
+        print("\n❌ Tests failed!")
+        return 1
+
+if __name__ == "__main__":
+    exit_code = asyncio.run(main())
+    sys.exit(exit_code)

test_tool_selection.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""
+Test the updated tool selection to ensure we use CryptoCompare/Etherscan instead of CoinGecko
+"""
+
+import asyncio
+import sys
+import os
+
+# Add src to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+from src.agent.research_agent import Web3ResearchAgent
+
+async def test_tool_selection():
+    """Test that the system prioritizes CryptoCompare and Etherscan over CoinGecko"""
+    print("🧪 Testing tool selection...")
+    
+    agent = Web3ResearchAgent()
+    
+    if not agent.enabled:
+        print("❌ Agent not enabled")
+        return False
+    
+    # Check which tools are initialized
+    tool_names = [tool.name for tool in agent.tools]
+    print(f"🛠️ Available tools: {tool_names}")
+    
+    # Verify CoinGecko is not in tools (since no API key)
+    if 'coingecko_data' in tool_names:
+        print("⚠️ CoinGecko tool is still initialized - this may cause API failures")
+    else:
+        print("✅ CoinGecko tool properly skipped (no API key)")
+    
+    # Verify we have the working tools
+    expected_tools = ['cryptocompare_data', 'etherscan_data', 'defillama_data', 'chart_data_provider']
+    working_tools = [tool for tool in expected_tools if tool in tool_names]
+    print(f"✅ Working tools available: {working_tools}")
+    
+    # Test a simple query
+    try:
+        print("\n📊 Testing Bitcoin price query...")
+        result = await agent.research_query("Analyze Bitcoin price trends", use_gemini=True)
+        
+        if result['success']:
+            print("✅ Query successful!")
+            print(f"📈 Result preview: {result['result'][:200]}...")
+            print(f"🔧 Tools used: {result.get('metadata', {}).get('tools_used', 'N/A')}")
+            return True
+        else:
+            print(f"❌ Query failed: {result.get('error', 'Unknown error')}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Test failed with exception: {e}")
+        return False
+
+async def main():
+    success = await test_tool_selection()
+    if success:
+        print("\n🎉 Tool selection test passed!")
+        return 0
+    else:
+        print("\n❌ Tool selection test failed!")
+        return 1
+
+if __name__ == "__main__":
+    exit_code = asyncio.run(main())
+    sys.exit(exit_code)