feat: testing done

README.md

@@ -1,6 +1,69 @@
-# Web3 Research Co-Pilot
+# 🚀 Web3 Research Co-Pilot
 
-AI-powered cryptocurrency research assistant built with LangChain and Gradio.
+AI-powered cryptocurrency research assistant with comprehensive Web3 data analysis capabilities.
+
+## Features
+
+- **LangChain AI Agent**: Advanced query processing with Google Gemini
+- **Real-time Data**: CoinGecko, DeFiLlama, Etherscan integration  
+- **Interactive UI**: Gradio-based chat interface with visualizations
+- **AIRAA Integration**: Research data forwarding to external platforms
+- **Production Ready**: Comprehensive error handling and async architecture
+
+## Quick Start
+
+### 1. Environment Setup
+
+```bash
+export GEMINI_API_KEY="your_gemini_api_key"
+export ETHERSCAN_API_KEY="your_etherscan_key"  # Optional
+export COINGECKO_API_KEY="your_coingecko_key"  # Optional
+```
+
+### 2. Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+### 3. Launch
+
+```bash
+python launch.py
+```
+
+## API Keys
+
+- **GEMINI_API_KEY** (Required): [Get from Google AI Studio](https://makersuite.google.com/app/apikey)
+- **ETHERSCAN_API_KEY** (Optional): [Get from Etherscan.io](https://etherscan.io/apis)
+- **COINGECKO_API_KEY** (Optional): [Get from CoinGecko](https://www.coingecko.com/en/api/pricing)
+
+## Architecture
+
+```
+├── app.py                 # Main Gradio application
+├── src/
+│   ├── agent/            # LangChain AI agent
+│   ├── tools/            # Web3 data tools
+│   ├── api/              # External integrations
+│   └── utils/            # Configuration & utilities
+└── launch.py             # Launch script
+```
+
+## Usage Examples
+
+- "What is the current price of Bitcoin?"
+- "Analyze Ethereum's DeFi ecosystem"
+- "Show me gas prices and network stats"
+- "Research the top DeFi protocols by TVL"
+
+## Deployment
+
+Configured for HuggingFace Spaces with automatic dependency management.
+
+---
+
+**Built with minimal, expert-level code and production-grade error handling.**
 
 ## Features
 

app.py

@@ -1,151 +0,0 @@
-import gradio as gr
-import asyncio
-import json
-from datetime import datetime
-from typing import List, Tuple
-
-from src.agent.research_agent import Web3ResearchAgent
-from src.api.airaa_integration import AIRAAIntegration  
-from src.visualizations import create_price_chart, create_market_overview
-from src.utils.logger import get_logger
-from src.utils.config import config
-
-logger = get_logger(__name__)
-
-class Web3CoPilotApp:
-    def __init__(self):
-        try:
-            self.agent = Web3ResearchAgent()
-            self.airaa = AIRAAIntegration()
-        except Exception as e:
-            logger.error(f"App initialization failed: {e}")
-            raise
-    
-    async def process_query(self, query: str, history: List[Tuple[str, str]]):
-        if not query.strip():
-            yield history, ""
-            return
-        
-        try:
-            history.append((query, "🔍 Researching..."))
-            yield history, ""
-            
-            result = await self.agent.research_query(query)
-            
-            if result["success"]:
-                response = result["result"]
-                sources = ", ".join(result.get("sources", []))
-                response += f"\n\n---\n📊 **Sources**: {sources}\n⏰ **Generated**: {datetime.now().strftime('%H:%M:%S')}"
-                
-                if config.AIRAA_WEBHOOK_URL:
-                    asyncio.create_task(self.airaa.send_research_data(result))
-            else:
-                response = f"❌ Error: {result.get('error', 'Research failed')}"
-            
-            history[-1] = (query, response)
-            yield history, ""
-            
-        except Exception as e:
-            logger.error(f"Query error: {e}")
-            history[-1] = (query, f"❌ System error: {str(e)}")
-            yield history, ""
-    
-    def get_chart_data(self, symbol: str):
-        try:
-            if not symbol.strip():
-                return "Please enter a symbol"
-            
-            data = asyncio.run(self.agent.get_price_history(symbol))
-            return create_price_chart(data, symbol)
-        except Exception as e:
-            logger.error(f"Chart error: {e}")
-            return f"Chart unavailable: {str(e)}"
-    
-    def get_market_overview(self):
-        try:
-            data = asyncio.run(self.agent.get_comprehensive_market_data())
-            return create_market_overview(data)
-        except Exception as e:
-            logger.error(f"Market overview error: {e}")
-            return f"Market data unavailable: {str(e)}"
-    
-    def create_interface(self):
-        with gr.Blocks(title=config.UI_TITLE, theme=gr.themes.Soft()) as demo:
-            gr.Markdown(f"""
-            # 🚀 {config.UI_TITLE}
-            {config.UI_DESCRIPTION}
-            **Powered by**: Gemini AI • CoinGecko • DeFiLlama • Etherscan
-            """)
-            
-            with gr.Row():
-                with gr.Column(scale=2):
-                    chatbot = gr.Chatbot(label="Research Assistant", height=650)
-                    
-                    with gr.Row():
-                        query_input = gr.Textbox(
-                            placeholder="Ask about crypto markets, DeFi protocols, or on-chain data...",
-                            label="Research Query", lines=2
-                        )
-                        submit_btn = gr.Button("🔍 Research", variant="primary")
-                    
-                    clear_btn = gr.Button("🗑️ Clear", variant="secondary")
-                
-                with gr.Column(scale=1):
-                    gr.Markdown("### 💡 Example Queries")
-                    
-                    examples = [
-                        "Bitcoin price analysis",
-                        "Top DeFi protocols by TVL",
-                        "Ethereum vs Solana comparison",
-                        "Trending cryptocurrencies",
-                        "DeFi yield opportunities"
-                    ]
-                    
-                    for example in examples:
-                        gr.Button(example, size="sm").click(
-                            lambda x=example: x, outputs=query_input
-                        )
-                    
-                    gr.Markdown("### 📈 Visualizations")
-                    chart_output = gr.Plot(label="Charts")
-                    
-                    symbol_input = gr.Textbox(placeholder="BTC, ETH, SOL...", label="Chart Symbol")
-                    chart_btn = gr.Button("📊 Generate Chart")
-                    
-                    market_btn = gr.Button("🌐 Market Overview")
-            
-            submit_btn.click(
-                self.process_query,
-                inputs=[query_input, chatbot],
-                outputs=[chatbot, query_input]
-            )
-            
-            query_input.submit(
-                self.process_query,
-                inputs=[query_input, chatbot],
-                outputs=[chatbot, query_input]
-            )
-            
-            clear_btn.click(lambda: ([], ""), outputs=[chatbot, query_input])
-            
-            chart_btn.click(
-                self.get_chart_data,
-                inputs=symbol_input,
-                outputs=chart_output
-            )
-            
-            market_btn.click(
-                self.get_market_overview,
-                outputs=chart_output
-            )
-        
-        return demo
-
-if __name__ == "__main__":
-    app = Web3CoPilotApp()
-    interface = app.create_interface()
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False
-    )

app_fastapi.py

@@ -0,0 +1,602 @@
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from fastapi.responses import HTMLResponse, JSONResponse
+from pydantic import BaseModel
+import asyncio
+import json
+from datetime import datetime
+from typing import List, Dict, Any, Optional
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from src.agent.research_agent import Web3ResearchAgent
+from src.api.airaa_integration import AIRAAIntegration  
+from src.utils.logger import get_logger
+from src.utils.config import config
+
+logger = get_logger(__name__)
+
+app = FastAPI(
+    title="Web3 Research Co-Pilot",
+    description="AI-powered cryptocurrency research assistant",
+    version="1.0.0"
+)
+
+# Pydantic models for request/response
+class QueryRequest(BaseModel):
+    query: str
+    chat_history: Optional[List[Dict[str, str]]] = []
+
+class QueryResponse(BaseModel):
+    success: bool
+    response: str
+    sources: Optional[List[str]] = []
+    metadata: Optional[Dict[str, Any]] = {}
+    error: Optional[str] = None
+
+class Web3CoPilotService:
+    def __init__(self):
+        try:
+            logger.info("🚀 Initializing Web3CoPilotService...")
+            logger.info(f"📋 GEMINI_API_KEY configured: {'Yes' if config.GEMINI_API_KEY else 'No'}")
+            
+            if config.GEMINI_API_KEY:
+                logger.info("🤖 Initializing AI agent...")
+                self.agent = Web3ResearchAgent()
+                logger.info("✅ AI agent initialized successfully")
+            else:
+                logger.warning("⚠️ GEMINI_API_KEY not found - AI features disabled")
+                self.agent = None
+            
+            logger.info("🔗 Initializing AIRAA integration...")
+            self.airaa = AIRAAIntegration()
+            logger.info(f"🔗 AIRAA integration: {'Enabled' if self.airaa.enabled else 'Disabled'}")
+            
+            self.enabled = bool(config.GEMINI_API_KEY)
+            logger.info(f"🎯 Web3CoPilotService initialized successfully (AI enabled: {self.enabled})")
+            
+        except Exception as e:
+            logger.error(f"❌ Service initialization failed: {e}")
+            self.agent = None
+            self.airaa = None
+            self.enabled = False
+    
+    async def process_query(self, query: str) -> QueryResponse:
+        logger.info(f"🔍 Processing query: {query[:50]}{'...' if len(query) > 50 else ''}")
+        
+        if not query.strip():
+            logger.warning("⚠️ Empty query received")
+            return QueryResponse(success=False, response="Please enter a query.", error="Empty query")
+        
+        try:
+            if not self.enabled:
+                logger.info("🔧 AI disabled - providing limited response")
+                response = """⚠️ **AI Agent Disabled**: GEMINI_API_KEY not configured.
+
+**Limited Data Available:**
+- CoinGecko API (basic crypto data)
+- DeFiLlama API (DeFi protocols) 
+- Etherscan API (gas prices)
+
+Please configure GEMINI_API_KEY for full AI analysis."""
+                return QueryResponse(success=True, response=response, sources=["Configuration"])
+            
+            logger.info("🤖 Sending query to AI agent...")
+            result = await self.agent.research_query(query)
+            logger.info(f"✅ AI agent responded: {result.get('success', False)}")
+            
+            if result.get("success"):
+                response = result.get("result", "No response generated")
+                sources = result.get("sources", [])
+                metadata = result.get("metadata", {})
+                
+                # Send to AIRAA if enabled
+                if self.airaa and self.airaa.enabled:
+                    try:
+                        logger.info("🔗 Sending data to AIRAA...")
+                        await self.airaa.send_research_data(query, response)
+                        logger.info("✅ Data sent to AIRAA successfully")
+                    except Exception as e:
+                        logger.warning(f"⚠️ AIRAA integration failed: {e}")
+                
+                logger.info("✅ Query processed successfully")
+                return QueryResponse(success=True, response=response, sources=sources, metadata=metadata)
+            else:
+                error_msg = result.get("error", "Research failed. Please try again.")
+                logger.error(f"❌ AI agent failed: {error_msg}")
+                return QueryResponse(success=False, response=error_msg, error=error_msg)
+            
+        except Exception as e:
+            logger.error(f"❌ Query processing error: {e}")
+            error_msg = f"Error processing query: {str(e)}"
+            return QueryResponse(success=False, response=error_msg, error=error_msg)
+
+# Initialize service
+logger.info("🚀 Starting Web3 Research Co-Pilot...")
+service = Web3CoPilotService()
+
+# API Routes
+@app.get("/", response_class=HTMLResponse)
+async def get_homepage(request: Request):
+    logger.info("📄 Serving homepage")
+    html_content = """
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Web3 Research Co-Pilot</title>
+        <link rel="icon" href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 100 100%22><text y=%22.9em%22 font-size=%2290%22>🚀</text></svg>">
+        <style>
+            * { margin: 0; padding: 0; box-sizing: border-box; }
+            body { 
+                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', sans-serif; 
+                background: linear-gradient(135deg, #0f1419 0%, #1a1f2e 100%); 
+                color: #e6e6e6; 
+                min-height: 100vh;
+                overflow-x: hidden;
+            }
+            .container { max-width: 1200px; margin: 0 auto; padding: 20px; }
+            .header { 
+                text-align: center; 
+                margin-bottom: 30px; 
+                background: linear-gradient(135deg, #00d4aa, #4a9eff);
+                -webkit-background-clip: text;
+                -webkit-text-fill-color: transparent;
+                background-clip: text;
+            }
+            .header h1 { 
+                font-size: 3em; 
+                margin-bottom: 10px; 
+                font-weight: 700;
+                text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+            }
+            .header p { 
+                color: #b0b0b0; 
+                font-size: 1.2em; 
+                font-weight: 300;
+            }
+            .status { 
+                padding: 15px; 
+                border-radius: 12px; 
+                margin-bottom: 25px; 
+                text-align: center; 
+                font-weight: 500;
+                box-shadow: 0 4px 15px rgba(0,0,0,0.2);
+                transition: all 0.3s ease;
+            }
+            .status.enabled { 
+                background: linear-gradient(135deg, #1a4d3a, #2a5d4a); 
+                border: 2px solid #00d4aa; 
+                color: #00d4aa; 
+            }
+            .status.disabled { 
+                background: linear-gradient(135deg, #4d1a1a, #5d2a2a); 
+                border: 2px solid #ff6b6b; 
+                color: #ff6b6b; 
+            }
+            .status.checking {
+                background: linear-gradient(135deg, #3a3a1a, #4a4a2a); 
+                border: 2px solid #ffdd59; 
+                color: #ffdd59;
+                animation: pulse 1.5s infinite;
+            }
+            @keyframes pulse {
+                0% { opacity: 1; }
+                50% { opacity: 0.7; }
+                100% { opacity: 1; }
+            }
+            .chat-container { 
+                background: rgba(26, 26, 26, 0.8); 
+                border-radius: 16px; 
+                padding: 25px; 
+                margin-bottom: 25px; 
+                backdrop-filter: blur(10px);
+                border: 1px solid rgba(255,255,255,0.1);
+                box-shadow: 0 8px 32px rgba(0,0,0,0.3);
+            }
+            .chat-messages { 
+                height: 450px; 
+                overflow-y: auto; 
+                background: rgba(10, 10, 10, 0.6); 
+                border-radius: 12px; 
+                padding: 20px; 
+                margin-bottom: 20px;
+                border: 1px solid rgba(255,255,255,0.05);
+            }
+            .chat-messages::-webkit-scrollbar { width: 6px; }
+            .chat-messages::-webkit-scrollbar-track { background: #2a2a2a; border-radius: 3px; }
+            .chat-messages::-webkit-scrollbar-thumb { background: #555; border-radius: 3px; }
+            .chat-messages::-webkit-scrollbar-thumb:hover { background: #777; }
+            .message { 
+                margin-bottom: 20px; 
+                padding: 16px; 
+                border-radius: 12px; 
+                transition: all 0.3s ease;
+                position: relative;
+            }
+            .message:hover { transform: translateY(-1px); box-shadow: 0 4px 12px rgba(0,0,0,0.2); }
+            .message.user { 
+                background: linear-gradient(135deg, #2a2a3a, #3a3a4a); 
+                border-left: 4px solid #00d4aa; 
+                margin-left: 50px;
+            }
+            .message.assistant { 
+                background: linear-gradient(135deg, #1a2a1a, #2a3a2a); 
+                border-left: 4px solid #4a9eff; 
+                margin-right: 50px;
+            }
+            .message .sender { 
+                font-weight: 600; 
+                margin-bottom: 8px; 
+                font-size: 0.9em; 
+                display: flex;
+                align-items: center;
+                gap: 8px;
+            }
+            .message.user .sender { color: #00d4aa; }
+            .message.assistant .sender { color: #4a9eff; }
+            .message .content { line-height: 1.6; }
+            .input-container { 
+                display: flex; 
+                gap: 12px; 
+                align-items: stretch;
+            }
+            .input-container input { 
+                flex: 1; 
+                padding: 16px; 
+                border: 2px solid #333; 
+                background: rgba(42, 42, 42, 0.8); 
+                color: #e6e6e6; 
+                border-radius: 12px; 
+                font-size: 16px;
+                backdrop-filter: blur(10px);
+                transition: all 0.3s ease;
+            }
+            .input-container input:focus { 
+                outline: none; 
+                border-color: #00d4aa; 
+                box-shadow: 0 0 0 3px rgba(0, 212, 170, 0.2);
+            }
+            .input-container input::placeholder { color: #888; }
+            .input-container button { 
+                padding: 16px 24px; 
+                background: linear-gradient(135deg, #00d4aa, #00b894); 
+                color: #000; 
+                border: none; 
+                border-radius: 12px; 
+                cursor: pointer; 
+                font-weight: 600;
+                font-size: 16px;
+                transition: all 0.3s ease;
+                white-space: nowrap;
+            }
+            .input-container button:hover:not(:disabled) { 
+                background: linear-gradient(135deg, #00b894, #00a085); 
+                transform: translateY(-2px);
+                box-shadow: 0 4px 12px rgba(0, 212, 170, 0.3);
+            }
+            .input-container button:active { transform: translateY(0); }
+            .input-container button:disabled { 
+                background: #666; 
+                cursor: not-allowed; 
+                transform: none;
+                box-shadow: none;
+            }
+            .examples { 
+                display: grid; 
+                grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); 
+                gap: 15px; 
+                margin-top: 25px; 
+            }
+            .example-btn { 
+                padding: 16px; 
+                background: linear-gradient(135deg, #2a2a3a, #3a3a4a); 
+                border: 2px solid #444; 
+                border-radius: 12px; 
+                cursor: pointer; 
+                text-align: center; 
+                transition: all 0.3s ease;
+                font-weight: 500;
+                position: relative;
+                overflow: hidden;
+            }
+            .example-btn:before {
+                content: '';
+                position: absolute;
+                top: 0;
+                left: -100%;
+                width: 100%;
+                height: 100%;
+                background: linear-gradient(90deg, transparent, rgba(0, 212, 170, 0.1), transparent);
+                transition: left 0.5s;
+            }
+            .example-btn:hover:before { left: 100%; }
+            .example-btn:hover { 
+                background: linear-gradient(135deg, #3a3a4a, #4a4a5a); 
+                border-color: #00d4aa; 
+                transform: translateY(-3px);
+                box-shadow: 0 6px 20px rgba(0, 212, 170, 0.2);
+            }
+            .loading { 
+                color: #ffdd59; 
+                font-style: italic; 
+                display: flex;
+                align-items: center;
+                gap: 8px;
+            }
+            .loading:after {
+                content: '';
+                width: 12px;
+                height: 12px;
+                border: 2px solid #ffdd59;
+                border-top: 2px solid transparent;
+                border-radius: 50%;
+                animation: spin 1s linear infinite;
+            }
+            @keyframes spin {
+                0% { transform: rotate(0deg); }
+                100% { transform: rotate(360deg); }
+            }
+            .sources { 
+                margin-top: 12px; 
+                font-size: 0.85em; 
+                color: #999; 
+                display: flex;
+                flex-wrap: wrap;
+                gap: 6px;
+            }
+            .sources .label { margin-right: 8px; font-weight: 600; }
+            .sources span { 
+                background: rgba(51, 51, 51, 0.8); 
+                padding: 4px 8px; 
+                border-radius: 6px; 
+                font-size: 0.8em;
+                border: 1px solid #555;
+            }
+            .welcome-message {
+                background: linear-gradient(135deg, #1a2a4a, #2a3a5a);
+                border-left: 4px solid #4a9eff;
+                border-radius: 12px;
+                padding: 16px;
+                margin-bottom: 20px;
+                text-align: center;
+            }
+            .footer {
+                text-align: center;
+                margin-top: 30px;
+                color: #666;
+                font-size: 0.9em;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="header">
+                <h1>🚀 Web3 Research Co-Pilot</h1>
+                <p>AI-powered cryptocurrency research assistant</p>
+            </div>
+            
+            <div id="status" class="status checking">
+                <span>🔄 Checking system status...</span>
+            </div>
+            
+            <div class="chat-container">
+                <div id="chatMessages" class="chat-messages">
+                    <div class="welcome-message">
+                        <div class="sender">🤖 AI Research Assistant</div>
+                        <div>👋 Welcome! I'm your Web3 Research Co-Pilot. Ask me anything about cryptocurrency markets, DeFi protocols, blockchain analysis, or trading insights.</div>
+                    </div>
+                </div>
+                <div class="input-container">
+                    <input type="text" id="queryInput" placeholder="Ask about Bitcoin, Ethereum, DeFi yields, market analysis..." maxlength="500">
+                    <button id="sendBtn" onclick="sendQuery()">🚀 Research</button>
+                </div>
+            </div>
+            
+            <div class="examples">
+                <div class="example-btn" onclick="setQuery('What is the current Bitcoin price and market sentiment?')">
+                    📈 Bitcoin Analysis
+                </div>
+                <div class="example-btn" onclick="setQuery('Show me the top DeFi protocols by TVL')">
+                    🏦 DeFi Overview
+                </div>
+                <div class="example-btn" onclick="setQuery('What are the trending cryptocurrencies today?')">
+                    🔥 Trending Coins
+                </div>
+                <div class="example-btn" onclick="setQuery('Analyze Ethereum gas prices and network activity')">
+                    ⛽ Gas Tracker
+                </div>
+                <div class="example-btn" onclick="setQuery('Find the best yield farming opportunities')">
+                    🌾 Yield Farming
+                </div>
+                <div class="example-btn" onclick="setQuery('Compare Solana vs Ethereum ecosystems')">
+                    ⚖️ Ecosystem Compare
+                </div>
+            </div>
+            
+            <div class="footer">
+                <p>Powered by AI • Real-time Web3 data • Built with ❤️</p>
+            </div>
+        </div>
+        
+        <script>
+            let chatHistory = [];
+            
+            async function checkStatus() {
+                try {
+                    console.log('🔍 Checking system status...');
+                    const response = await fetch('/status');
+                    const status = await response.json();
+                    console.log('📊 Status received:', status);
+                    
+                    const statusDiv = document.getElementById('status');
+                    
+                    if (status.enabled && status.gemini_configured) {
+                        statusDiv.className = 'status enabled';
+                        statusDiv.innerHTML = `
+                            <span>✅ AI Research Agent: Online</span><br>
+                            <small>Tools available: ${status.tools_available.join(', ')}</small>
+                        `;
+                        console.log('✅ System fully operational');
+                    } else {
+                        statusDiv.className = 'status disabled';
+                        statusDiv.innerHTML = `
+                            <span>⚠️ Limited Mode: GEMINI_API_KEY not configured</span><br>
+                            <small>Basic data available: ${status.tools_available.join(', ')}</small>
+                        `;
+                        console.log('⚠️ System in limited mode');
+                    }
+                } catch (error) {
+                    console.error('❌ Status check failed:', error);
+                    const statusDiv = document.getElementById('status');
+                    statusDiv.className = 'status disabled';
+                    statusDiv.innerHTML = '<span>❌ Connection Error</span>';
+                }
+            }
+            
+            async function sendQuery() {
+                const input = document.getElementById('queryInput');
+                const sendBtn = document.getElementById('sendBtn');
+                const query = input.value.trim();
+                
+                if (!query) {
+                    input.focus();
+                    return;
+                }
+                
+                console.log('📤 Sending query:', query);
+                
+                // Add user message
+                addMessage('user', query);
+                input.value = '';
+                
+                // Show loading
+                sendBtn.disabled = true;
+                sendBtn.innerHTML = '<span class="loading">Processing</span>';
+                
+                try {
+                    const response = await fetch('/query', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ query, chat_history: chatHistory })
+                    });
+                    
+                    const result = await response.json();
+                    console.log('📥 Response received:', result);
+                    
+                    if (result.success) {
+                        addMessage('assistant', result.response, result.sources);
+                        console.log('✅ Query processed successfully');
+                    } else {
+                        addMessage('assistant', result.response || 'An error occurred');
+                        console.log('⚠️ Query failed:', result.error);
+                    }
+                } catch (error) {
+                    console.error('❌ Network error:', error);
+                    addMessage('assistant', '❌ Network error. Please check your connection and try again.');
+                } finally {
+                    sendBtn.disabled = false;
+                    sendBtn.innerHTML = '🚀 Research';
+                    input.focus();
+                }
+            }
+            
+            function addMessage(sender, content, sources = []) {
+                console.log(`💬 Adding ${sender} message`);
+                const messagesDiv = document.getElementById('chatMessages');
+                const messageDiv = document.createElement('div');
+                messageDiv.className = `message ${sender}`;
+                
+                let sourcesHtml = '';
+                if (sources && sources.length > 0) {
+                    sourcesHtml = `<div class="sources"><span class="label">Sources:</span> ${sources.map(s => `<span>${s}</span>`).join('')}</div>`;
+                }
+                
+                const senderIcon = sender === 'user' ? '👤' : '🤖';
+                const senderName = sender === 'user' ? 'You' : 'AI Research Assistant';
+                
+                messageDiv.innerHTML = `
+                    <div class="sender">${senderIcon} ${senderName}</div>
+                    <div class="content">${content.replace(/\n/g, '<br>')}</div>
+                    ${sourcesHtml}
+                `;
+                
+                messagesDiv.appendChild(messageDiv);
+                messagesDiv.scrollTop = messagesDiv.scrollHeight;
+                
+                // Update chat history
+                chatHistory.push({ role: sender, content });
+                if (chatHistory.length > 20) chatHistory = chatHistory.slice(-20);
+            }
+            
+            function setQuery(query) {
+                console.log('📝 Setting query:', query);
+                const input = document.getElementById('queryInput');
+                input.value = query;
+                input.focus();
+                
+                // Optional: auto-send after a short delay
+                setTimeout(() => {
+                    if (input.value === query) { // Only if user didn't change it
+                        sendQuery();
+                    }
+                }, 100);
+            }
+            
+            // Handle Enter key
+            document.getElementById('queryInput').addEventListener('keypress', function(e) {
+                if (e.key === 'Enter') {
+                    sendQuery();
+                }
+            });
+            
+            // Initialize
+            document.addEventListener('DOMContentLoaded', function() {
+                console.log('🚀 Web3 Research Co-Pilot initialized');
+                checkStatus();
+                document.getElementById('queryInput').focus();
+            });
+        </script>
+    </body>
+    </html>
+    """
+    return HTMLResponse(content=html_content)
+
+@app.get("/status")
+async def get_status():
+    logger.info("📊 Status endpoint called")
+    status = {
+        "enabled": service.enabled,
+        "gemini_configured": bool(config.GEMINI_API_KEY),
+        "tools_available": ["CoinGecko", "DeFiLlama", "Etherscan"],
+        "airaa_enabled": service.airaa.enabled if service.airaa else False,
+        "timestamp": datetime.now().isoformat()
+    }
+    logger.info(f"📊 Status response: {status}")
+    return status
+
+@app.post("/query", response_model=QueryResponse)
+async def process_query(request: QueryRequest):
+    logger.info(f"📥 Query endpoint called: {request.query[:50]}{'...' if len(request.query) > 50 else ''}")
+    result = await service.process_query(request.query)
+    logger.info(f"📤 Query response: success={result.success}")
+    return result
+
+@app.get("/health")
+async def health_check():
+    logger.info("❤️ Health check endpoint called")
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "service_enabled": service.enabled,
+        "version": "1.0.0"
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    logger.info("🌟 Starting FastAPI server...")
+    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")

attached_assets/Pasted--Complete-Web3-Research-Co-Pilot-Project-Plan-Structure-Project-Directory-Structure--1754811430335_1754811430338.txt

@@ -1,992 +0,0 @@
-# Complete Web3 Research Co-Pilot Project Plan & Structure
-
-## 🏗️ **Project Directory Structure**
-
-```
-web3-research-copilot/
-├── README.md
-├── requirements.txt
-├── app.py                          # Main Gradio application
-├── .env.example                    # Environment variables template
-├── .gitignore
-├── Dockerfile                      # For HF Spaces deployment
-├── 
-├── src/
-│   ├── __init__.py
-│   ├── agent/
-│   │   ├── __init__.py
-│   │   ├── research_agent.py       # Main LangChain agent
-│   │   ├── query_planner.py        # Multi-step query breakdown
-│   │   ├── memory_manager.py       # Conversation memory
-│   │   └── response_formatter.py   # Output formatting
-│   │
-│   ├── tools/
-│   │   ├── __init__.py
-│   │   ├── base_tool.py           # Abstract base tool class
-│   │   ├── coingecko_tool.py      # CoinGecko API integration
-│   │   ├── defillama_tool.py      # DeFiLlama API integration
-│   │   ├── etherscan_tool.py      # Etherscan API integration
-│   │   ├── cryptocompare_tool.py  # CryptoCompare API integration
-│   │   └── social_tool.py         # Social media data (Twitter API)
-│   │
-│   ├── data/
-│   │   ├── __init__.py
-│   │   ├── processors/
-│   │   │   ├── __init__.py
-│   │   │   ├── price_processor.py
-│   │   │   ├── volume_processor.py
-│   │   │   └── social_processor.py
-│   │   ├── cache/
-│   │   │   ├── __init__.py
-│   │   │   └── redis_cache.py     # Simple in-memory cache
-│   │   └── validators/
-│   │       ├── __init__.py
-│   │       └── data_validator.py
-│   │
-│   ├── ui/
-│   │   ├── __init__.py
-│   │   ├── gradio_interface.py    # Main UI components
-│   │   ├── components/
-│   │   │   ├── __init__.py
-│   │   │   ├── chat_component.py
-│   │   │   ├── chart_component.py
-│   │   │   └── table_component.py
-│   │   └── styles/
-│   │       ├── custom.css
-│   │       └── theme.py
-│   │
-│   ├── api/
-│   │   ├── __init__.py
-│   │   ├── airaa_integration.py   # AIRAA-specific API endpoints
-│   │   ├── webhook_handler.py     # For AIRAA integration
-│   │   └── rate_limiter.py        # API rate limiting
-│   │
-│   ├── utils/
-│   │   ├── __init__.py
-│   │   ├── logger.py              # Logging configuration
-│   │   ├── config.py              # Configuration management
-│   │   ├── exceptions.py          # Custom exceptions
-│   │   └── helpers.py             # Utility functions
-│   │
-│   └── visualizations/
-│       ├── __init__.py
-│       ├── plotly_charts.py       # Interactive charts
-│       ├── tables.py              # Data tables
-│       └── export_utils.py        # Data export functions
-│
-├── tests/
-│   ├── __init__.py
-│   ├── test_agent/
-│   │   ├── test_research_agent.py
-│   │   └── test_query_planner.py
-│   ├── test_tools/
-│   │   ├── test_coingecko.py
-│   │   └── test_defillama.py
-│   └── test_integration/
-│       └── test_airaa_integration.py
-│
-├── docs/
-│   ├── API.md                     # API documentation
-│   ├── DEPLOYMENT.md              # Deployment guide
-│   ├── AIRAA_INTEGRATION.md       # AIRAA integration guide
-│   └── USER_GUIDE.md              # User documentation
-│
-├── examples/
-│   ├── sample_queries.py          # Example research queries
-│   ├── api_examples.py            # API usage examples
-│   └── airaa_webhook_example.py   # AIRAA integration example
-│
-└── deployment/
-    ├── docker-compose.yml
-    ├── nginx.conf
-    └── huggingface_spaces/
-        ├── spaces_config.yml
-        └── deployment_script.sh
-```
-
-## 📋 **Detailed Implementation Plan**
-
-### **Phase 1: Foundation Setup (Days 1-2)**
-
-#### Day 1: Project Structure & Core Setup
-```bash
-# Setup commands
-mkdir web3-research-copilot
-cd web3-research-copilot
-python -m venv venv
-source venv/bin/activate  # On Windows: venv\Scripts\activate
-pip install --upgrade pip
-```
-
-**Key Files to Create:**
-
-**requirements.txt**
-```txt
-# Core AI/ML
-langchain==0.1.0
-langchain-google-genai==1.0.0
-langchain-community==0.0.20
-
-# Web Framework
-gradio==4.15.0
-fastapi==0.108.0
-uvicorn==0.25.0
-
-# Data Processing
-pandas==2.1.4
-numpy==1.24.3
-requests==2.31.0
-python-dotenv==1.0.0
-
-# Visualization
-plotly==5.17.0
-matplotlib==3.8.2
-
-# Utilities
-pydantic==2.5.2
-python-dateutil==2.8.2
-tenacity==8.2.3
-
-# Caching & Performance
-diskcache==5.6.3
-asyncio-throttle==1.0.2
-
-# Testing
-pytest==7.4.3
-pytest-asyncio==0.21.1
-```
-
-**src/utils/config.py**
-```python
-import os
-from dotenv import load_dotenv
-from dataclasses import dataclass
-from typing import Optional
-
-load_dotenv()
-
-@dataclass
-class Config:
-    # AI Configuration
-    GEMINI_API_KEY: str = os.getenv("GEMINI_API_KEY")
-    GEMINI_MODEL: str = "gemini-pro"
-    
-    # API Keys
-    COINGECKO_API_KEY: Optional[str] = os.getenv("COINGECKO_API_KEY")
-    ETHERSCAN_API_KEY: str = os.getenv("ETHERSCAN_API_KEY")
-    CRYPTOCOMPARE_API_KEY: Optional[str] = os.getenv("CRYPTOCOMPARE_API_KEY")
-    
-    # Rate Limits (per minute)
-    COINGECKO_RATE_LIMIT: int = 10
-    ETHERSCAN_RATE_LIMIT: int = 5
-    GEMINI_RATE_LIMIT: int = 15
-    
-    # Cache Configuration
-    CACHE_TTL: int = 300  # 5 minutes
-    CACHE_SIZE: int = 100
-    
-    # UI Configuration
-    UI_TITLE: str = "Web3 Research Co-Pilot"
-    UI_DESCRIPTION: str = "AI-powered crypto research assistant"
-    
-    # AIRAA Integration
-    AIRAA_WEBHOOK_URL: Optional[str] = os.getenv("AIRAA_WEBHOOK_URL")
-    AIRAA_API_KEY: Optional[str] = os.getenv("AIRAA_API_KEY")
-    
-    # Logging
-    LOG_LEVEL: str = "INFO"
-    LOG_FILE: str = "app.log"
-
-config = Config()
-```
-
-#### Day 2: Base Tool Architecture
-
-**src/tools/base_tool.py**
-```python
-from abc import ABC, abstractmethod
-from typing import Dict, Any, Optional
-from langchain.tools import BaseTool
-from pydantic import BaseModel, Field
-import asyncio
-from tenacity import retry, stop_after_attempt, wait_exponential
-from src.utils.logger import get_logger
-
-logger = get_logger(__name__)
-
-class Web3ToolInput(BaseModel):
-    query: str = Field(description="The search query or parameter")
-    filters: Optional[Dict[str, Any]] = Field(default=None, description="Additional filters")
-
-class BaseWeb3Tool(BaseTool, ABC):
-    """Base class for all Web3 data tools"""
-    
-    name: str = "base_web3_tool"
-    description: str = "Base Web3 tool"
-    args_schema = Web3ToolInput
-    
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.rate_limiter = self._setup_rate_limiter()
-    
-    @abstractmethod
-    def _setup_rate_limiter(self):
-        """Setup rate limiting for the specific API"""
-        pass
-    
-    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
-    async def _make_api_call(self, url: str, params: Dict[str, Any]) -> Dict[str, Any]:
-        """Make rate-limited API call with retry logic"""
-        await self.rate_limiter.acquire()
-        # Implementation will be in specific tools
-        pass
-    
-    @abstractmethod
-    def _process_response(self, response: Dict[str, Any]) -> str:
-        """Process API response into readable format"""
-        pass
-    
-    def _run(self, query: str, filters: Optional[Dict[str, Any]] = None) -> str:
-        """Synchronous tool execution"""
-        return asyncio.run(self._arun(query, filters))
-    
-    @abstractmethod
-    async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None) -> str:
-        """Asynchronous tool execution"""
-        pass
-```
-
-### **Phase 2: Data Tools Implementation (Days 3-4)**
-
-#### CoinGecko Tool
-**src/tools/coingecko_tool.py**
-```python
-import aiohttp
-from typing import Dict, Any, Optional
-from asyncio_throttle import Throttler
-from src.tools.base_tool import BaseWeb3Tool, Web3ToolInput
-from src.utils.config import config
-
-class CoinGeckoTool(BaseWeb3Tool):
-    name = "coingecko_price_data"
-    description = """
-    Get cryptocurrency price, volume, market cap and trend data from CoinGecko.
-    Useful for: price analysis, market cap rankings, volume trends, price changes.
-    Input should be a cryptocurrency name or symbol (e.g., 'bitcoin', 'ethereum', 'BTC').
-    """
-    
-    def _setup_rate_limiter(self):
-        return Throttler(rate_limit=config.COINGECKO_RATE_LIMIT, period=60)
-    
-    async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None) -> str:
-        try:
-            # Clean and format the query
-            coin_id = self._format_coin_id(query)
-            
-            # API endpoints
-            base_url = "https://api.coingecko.com/api/v3"
-            
-            if filters and filters.get("type") == "trending":
-                url = f"{base_url}/search/trending"
-                params = {}
-            elif filters and filters.get("type") == "market_data":
-                url = f"{base_url}/coins/{coin_id}"
-                params = {"localization": "false", "tickers": "false", "community_data": "false"}
-            else:
-                url = f"{base_url}/simple/price"
-                params = {
-                    "ids": coin_id,
-                    "vs_currencies": "usd",
-                    "include_24hr_change": "true",
-                    "include_24hr_vol": "true",
-                    "include_market_cap": "true"
-                }
-            
-            async with aiohttp.ClientSession() as session:
-                await self.rate_limiter.acquire()
-                async with session.get(url, params=params) as response:
-                    if response.status == 200:
-                        data = await response.json()
-                        return self._process_response(data, filters)
-                    else:
-                        return f"Error fetching data: HTTP {response.status}"
-                        
-        except Exception as e:
-            return f"Error in CoinGecko tool: {str(e)}"
-    
-    def _format_coin_id(self, query: str) -> str:
-        """Convert common symbols to CoinGecko IDs"""
-        symbol_map = {
-            "btc": "bitcoin",
-            "eth": "ethereum", 
-            "usdc": "usd-coin",
-            "usdt": "tether",
-            "bnb": "binancecoin"
-        }
-        return symbol_map.get(query.lower(), query.lower())
-    
-    def _process_response(self, data: Dict[str, Any], filters: Optional[Dict[str, Any]] = None) -> str:
-        """Format CoinGecko response into readable text"""
-        if not data:
-            return "No data found"
-            
-        if filters and filters.get("type") == "trending":
-            trending = data.get("coins", [])[:5]
-            result = "🔥 Trending Cryptocurrencies:\n"
-            for i, coin in enumerate(trending, 1):
-                name = coin.get("item", {}).get("name", "Unknown")
-                symbol = coin.get("item", {}).get("symbol", "")
-                result += f"{i}. {name} ({symbol.upper()})\n"
-            return result
-        
-        elif filters and filters.get("type") == "market_data":
-            name = data.get("name", "Unknown")
-            symbol = data.get("symbol", "").upper()
-            current_price = data.get("market_data", {}).get("current_price", {}).get("usd", 0)
-            market_cap = data.get("market_data", {}).get("market_cap", {}).get("usd", 0)
-            volume_24h = data.get("market_data", {}).get("total_volume", {}).get("usd", 0)
-            price_change_24h = data.get("market_data", {}).get("price_change_percentage_24h", 0)
-            
-            result = f"📊 {name} ({symbol}) Market Data:\n"
-            result += f"💰 Price: ${current_price:,.2f}\n"
-            result += f"📈 24h Change: {price_change_24h:+.2f}%\n"
-            result += f"🏦 Market Cap: ${market_cap:,.0f}\n"
-            result += f"📊 24h Volume: ${volume_24h:,.0f}\n"
-            return result
-        
-        else:
-            # Simple price data
-            result = "💰 Price Data:\n"
-            for coin_id, coin_data in data.items():
-                price = coin_data.get("usd", 0)
-                change_24h = coin_data.get("usd_24h_change", 0)
-                volume_24h = coin_data.get("usd_24h_vol", 0)
-                market_cap = coin_data.get("usd_market_cap", 0)
-                
-                result += f"🪙 {coin_id.title()}:\n"
-                result += f"  💵 Price: ${price:,.2f}\n"
-                result += f"  📈 24h Change: {change_24h:+.2f}%\n"
-                result += f"  📊 Volume: ${volume_24h:,.0f}\n"
-                result += f"  🏦 Market Cap: ${market_cap:,.0f}\n"
-            
-            return result
-```
-
-### **Phase 3: LangChain Agent Implementation (Days 5-6)**
-
-#### Main Research Agent
-**src/agent/research_agent.py**
-```python
-from langchain.agents import AgentExecutor, create_openai_tools_agent
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langchain.memory import ConversationBufferWindowMemory
-from typing import List, Dict, Any
-import asyncio
-
-from src.tools.coingecko_tool import CoinGeckoTool
-from src.tools.defillama_tool import DeFiLlamaTool
-from src.tools.etherscan_tool import EtherscanTool
-from src.agent.query_planner import QueryPlanner
-from src.utils.config import config
-from src.utils.logger import get_logger
-
-logger = get_logger(__name__)
-
-class Web3ResearchAgent:
-    def __init__(self):
-        self.llm = ChatGoogleGenerativeAI(
-            model=config.GEMINI_MODEL,
-            google_api_key=config.GEMINI_API_KEY,
-            temperature=0.1,
-            max_tokens=2048
-        )
-        
-        self.tools = self._setup_tools()
-        self.query_planner = QueryPlanner(self.llm)
-        self.memory = ConversationBufferWindowMemory(
-            memory_key="chat_history",
-            return_messages=True,
-            k=10
-        )
-        
-        self.agent = self._create_agent()
-        self.agent_executor = AgentExecutor(
-            agent=self.agent,
-            tools=self.tools,
-            memory=self.memory,
-            verbose=True,
-            max_iterations=5,
-            handle_parsing_errors=True
-        )
-    
-    def _setup_tools(self) -> List:
-        """Initialize all available tools"""
-        return [
-            CoinGeckoTool(),
-            DeFiLlamaTool(),
-            EtherscanTool(),
-        ]
-    
-    def _create_agent(self):
-        """Create the LangChain agent with custom prompt"""
-        system_prompt = """
-        You are an expert Web3 research assistant. Your job is to help users analyze cryptocurrency markets, 
-        DeFi protocols, and blockchain data by using available tools to gather accurate information.
-
-        Available tools:
-        - CoinGecko: Get price, volume, market cap data for cryptocurrencies
-        - DeFiLlama: Get DeFi protocol data, TVL, yields information  
-        - Etherscan: Get on-chain transaction and address data
-
-        Guidelines:
-        1. Break down complex queries into specific, actionable steps
-        2. Use multiple tools when needed to provide comprehensive analysis
-        3. Always cite your data sources in responses
-        4. Format responses with clear headers, bullet points, and emojis for readability
-        5. If data is unavailable, suggest alternative approaches or mention limitations
-        6. Provide context and explanations for technical terms
-        7. Include relevant charts or visualizations when possible
-
-        When responding:
-        - Start with a brief summary
-        - Present data in organized sections
-        - Include methodology notes
-        - End with key insights or actionable conclusions
-        """
-        
-        prompt = ChatPromptTemplate.from_messages([
-            ("system", system_prompt),
-            MessagesPlaceholder("chat_history"),
-            ("human", "{input}"),
-            MessagesPlaceholder("agent_scratchpad")
-        ])
-        
-        return create_openai_tools_agent(
-            llm=self.llm,
-            tools=self.tools,
-            prompt=prompt
-        )
-    
-    async def research_query(self, query: str) -> Dict[str, Any]:
-        """Main entry point for research queries"""
-        try:
-            logger.info(f"Processing query: {query}")
-            
-            # Plan the research approach
-            research_plan = await self.query_planner.plan_research(query)
-            logger.info(f"Research plan: {research_plan}")
-            
-            # Execute the research
-            result = await self._execute_research(query, research_plan)
-            
-            # Format and return response
-            return {
-                "success": True,
-                "query": query,
-                "research_plan": research_plan,
-                "result": result,
-                "sources": self._extract_sources(result),
-                "metadata": {
-                    "tools_used": [tool.name for tool in self.tools],
-                    "timestamp": self._get_timestamp()
-                }
-            }
-            
-        except Exception as e:
-            logger.error(f"Error processing query: {str(e)}")
-            return {
-                "success": False,
-                "query": query,
-                "error": str(e),
-                "metadata": {"timestamp": self._get_timestamp()}
-            }
-    
-    async def _execute_research(self, query: str, plan: Dict[str, Any]) -> str:
-        """Execute the research plan using LangChain agent"""
-        try:
-            # Add planning context to the query
-            enhanced_query = f"""
-            Research Query: {query}
-            
-            Research Plan: {plan.get('steps', [])}
-            Priority Focus: {plan.get('priority', 'general analysis')}
-            
-            Please execute this research systematically and provide a comprehensive analysis.
-            """
-            
-            response = await asyncio.to_thread(
-                self.agent_executor.invoke,
-                {"input": enhanced_query}
-            )
-            
-            return response.get("output", "No response generated")
-            
-        except Exception as e:
-            logger.error(f"Error executing research: {str(e)}")
-            return f"Research execution error: {str(e)}"
-    
-    def _extract_sources(self, result: str) -> List[str]:
-        """Extract data sources from the result"""
-        sources = []
-        if "CoinGecko" in result:
-            sources.append("CoinGecko API")
-        if "DeFiLlama" in result:
-            sources.append("DeFiLlama API")
-        if "Etherscan" in result:
-            sources.append("Etherscan API")
-        return sources
-    
-    def _get_timestamp(self) -> str:
-        """Get current timestamp"""
-        from datetime import datetime
-        return datetime.now().isoformat()
-```
-
-### **Phase 4: UI & Integration (Days 7-8)**
-
-#### Main Gradio Application
-**app.py**
-```python
-import gradio as gr
-import asyncio
-import json
-from datetime import datetime
-from typing import List, Tuple
-
-from src.agent.research_agent import Web3ResearchAgent
-from src.api.airaa_integration import AIRAAIntegration
-from src.visualizations.plotly_charts import create_price_chart, create_volume_chart
-from src.utils.config import config
-from src.utils.logger import get_logger
-
-logger = get_logger(__name__)
-
-class Web3CoPilotApp:
-    def __init__(self):
-        self.agent = Web3ResearchAgent()
-        self.airaa_integration = AIRAAIntegration()
-        
-    def create_interface(self):
-        """Create the main Gradio interface"""
-        
-        # Custom CSS for better styling
-        custom_css = """
-        .container { max-width: 1200px; margin: 0 auto; }
-        .chat-container { height: 600px; }
-        .query-box { font-size: 16px; }
-        .examples-box { background: #f8f9fa; padding: 15px; border-radius: 8px; }
-        """
-        
-        with gr.Blocks(
-            title=config.UI_TITLE,
-            css=custom_css,
-            theme=gr.themes.Soft()
-        ) as demo:
-            
-            # Header
-            gr.Markdown(f"""
-            # 🚀 {config.UI_TITLE}
-            
-            {config.UI_DESCRIPTION}
-            
-            **Powered by**: Gemini AI • CoinGecko • DeFiLlama • Etherscan
-            """)
-            
-            with gr.Row():
-                with gr.Column(scale=2):
-                    # Main Chat Interface
-                    chatbot = gr.Chatbot(
-                        label="Research Assistant",
-                        height=600,
-                        show_label=True,
-                        container=True,
-                        elem_classes=["chat-container"]
-                    )
-                    
-                    with gr.Row():
-                        query_input = gr.Textbox(
-                            placeholder="Ask me about crypto markets, DeFi protocols, or on-chain data...",
-                            label="Research Query",
-                            lines=2,
-                            elem_classes=["query-box"]
-                        )
-                        submit_btn = gr.Button("🔍 Research", variant="primary")
-                    
-                    # Quick action buttons
-                    with gr.Row():
-                        clear_btn = gr.Button("🗑️ Clear", variant="secondary")
-                        export_btn = gr.Button("📊 Export", variant="secondary")
-                
-                with gr.Column(scale=1):
-                    # Example queries sidebar
-                    gr.Markdown("### 💡 Example Queries")
-                    
-                    examples = [
-                        "What's the current price and 24h change for Bitcoin?",
-                        "Show me top DeFi protocols by TVL",
-                        "Which tokens had highest volume yesterday?", 
-                        "Compare Ethereum vs Solana market metrics",
-                        "What are the trending cryptocurrencies today?"
-                    ]
-                    
-                    for example in examples:
-                        example_btn = gr.Button(example, size="sm")
-                        example_btn.click(
-                            lambda x=example: x,
-                            outputs=query_input
-                        )
-                    
-                    # Data visualization area
-                    gr.Markdown("### 📈 Visualizations")
-                    chart_output = gr.Plot(label="Charts")
-                    
-                    # Export options
-                    gr.Markdown("### 📤 Export Options")
-                    export_format = gr.Radio(
-                        choices=["JSON", "CSV", "PDF"],
-                        value="JSON",
-                        label="Format"
-                    )
-            
-            # Chat functionality
-            def respond(message: str, history: List[Tuple[str, str]]):
-                """Process user message and generate response"""
-                if not message.strip():
-                    return history, ""
-                
-                try:
-                    # Show loading message
-                    history.append((message, "🔍 Researching... Please wait."))
-                    yield history, ""
-                    
-                    # Process the query
-                    result = asyncio.run(self.agent.research_query(message))
-                    
-                    if result["success"]:
-                        response = result["result"]
-                        
-                        # Add metadata footer
-                        sources = ", ".join(result["sources"])
-                        response += f"\n\n---\n📊 **Sources**: {sources}"
-                        response += f"\n⏰ **Generated**: {datetime.now().strftime('%H:%M:%S')}"
-                        
-                        # Send to AIRAA if configured
-                        if config.AIRAA_WEBHOOK_URL:
-                            asyncio.run(self.airaa_integration.send_research_data(result))
-                    
-                    else:
-                        response = f"❌ Error: {result.get('error', 'Unknown error occurred')}"
-                    
-                    # Update history
-                    history[-1] = (message, response)
-                    
-                except Exception as e:
-                    logger.error(f"Error in respond: {str(e)}")
-                    history[-1] = (message, f"❌ System error: {str(e)}")
-                
-                yield history, ""
-            
-            def clear_chat():
-                """Clear chat history"""
-                return [], ""
-            
-            def export_conversation(history: List[Tuple[str, str]], format_type: str):
-                """Export conversation in selected format"""
-                try:
-                    if format_type == "JSON":
-                        data = {
-                            "conversation": [{"query": q, "response": r} for q, r in history],
-                            "exported_at": datetime.now().isoformat()
-                        }
-                        return json.dumps(data, indent=2)
-                    
-                    elif format_type == "CSV":
-                        import csv
-                        import io
-                        output = io.StringIO()
-                        writer = csv.writer(output)
-                        writer.writerow(["Query", "Response", "Timestamp"])
-                        for q, r in history:
-                            writer.writerow([q, r, datetime.now().isoformat()])
-                        return output.getvalue()
-                    
-                    else:  # PDF
-                        return "PDF export not implemented yet"
-                        
-                except Exception as e:
-                    return f"Export error: {str(e)}"
-            
-            # Event handlers
-            submit_btn.click(
-                respond,
-                inputs=[query_input, chatbot],
-                outputs=[chatbot, query_input]
-            )
-            
-            query_input.submit(
-                respond,
-                inputs=[query_input, chatbot], 
-                outputs=[chatbot, query_input]
-            )
-            
-            clear_btn.click(
-                clear_chat,
-                outputs=[chatbot, query_input]
-            )
-            
-            export_btn.click(
-                export_conversation,
-                inputs=[chatbot, export_format],
-                outputs=gr.Textbox(label="Exported Data")
-            )
-        
-        return demo
-
-if __name__ == "__main__":
-    app = Web3CoPilotApp()
-    interface = app.create_interface()
-    
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        show_api=True
-    )
-```
-
-### **Phase 5: AIRAA Integration & Deployment**
-
-#### AIRAA Integration Module
-**src/api/airaa_integration.py**
-```python
-import aiohttp
-import json
-from typing import Dict, Any, Optional
-from src.utils.config import config
-from src.utils.logger import get_logger
-
-logger = get_logger(__name__)
-
-class AIRAAIntegration:
-    """Handle integration with AIRAA platform"""
-    
-    def __init__(self):
-        self.webhook_url = config.AIRAA_WEBHOOK_URL
-        self.api_key = config.AIRAA_API_KEY
-        self.enabled = bool(self.webhook_url)
-    
-    async def send_research_data(self, research_result: Dict[str, Any]) -> bool:
-        """Send research data to AIRAA webhook"""
-        if not self.enabled:
-            logger.info("AIRAA integration not configured, skipping")
-            return False
-        
-        try:
-            payload = self._format_for_airaa(research_result)
-            
-            headers = {
-                "Content-Type": "application/json",
-                "User-Agent": "Web3-Research-Copilot/1.0"
-            }
-            
-            if self.api_key:
-                headers["Authorization"] = f"Bearer {self.api_key}"
-            
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
-                    self.webhook_url,
-                    json=payload,
-                    headers=headers,
-                    timeout=aiohttp.ClientTimeout(total=30)
-                ) as response:
-                    
-                    if response.status == 200:
-                        logger.info("Successfully sent data to AIRAA")
-                        return True
-                    else:
-                        logger.warning(f"AIRAA webhook returned {response.status}")
-                        return False
-                        
-        except Exception as e:
-            logger.error(f"Failed to send data to AIRAA: {str(e)}")
-            return False
-    
-    def _format_for_airaa(self, research_result: Dict[str, Any]) -> Dict[str, Any]:
-        """Format research result for AIRAA consumption"""
-        return {
-            "source": "web3-research-copilot",
-            "timestamp": research_result["metadata"]["timestamp"],
-            "query": research_result["query"],
-            "research_plan": research_result.get("research_plan"),
-            "findings": research_result["result"],
-            "data_sources": research_result["sources"],
-            "confidence_score": self._calculate_confidence(research_result),
-            "tags": self._extract_tags(research_result["query"]),
-            "structured_data": self._extract_structured_data(research_result["result"])
-        }
-    
-    def _calculate_confidence(self, result: Dict[str, Any]) -> float:
-        """Calculate confidence score based on data sources and completeness"""
-        base_score = 0.7
-        
-        # Boost for multiple sources
-        source_count = len(result.get("sources", []))
-        source_boost = min(source_count * 0.1, 0.3)
-        
-        # Reduce for errors
-        error_penalty = 0.3 if not result.get("success", True) else 0
-        
-        return max(0.0, min(1.0, base_score + source_boost - error_penalty))
-    
-    def _extract_tags(self, query: str) -> List[str]:
-        """Extract relevant tags from query"""
-        tags = []
-        query_lower = query.lower()
-        
-        # Asset tags
-        if any(word in query_lower for word in ["bitcoin", "btc"]):
-            tags.append("bitcoin")
-        if any(word in query_lower for word in ["ethereum", "eth"]):
-            tags.append("ethereum")
-        
-        # Category tags
-        if any(word in query_lower for word in ["defi", "defillama"]):
-            tags.append("defi")
-        if any(word in query_lower for word in ["price", "market"]):
-            tags.append("market-analysis")
-        if any(word in query_lower for word in ["volume", "trading"]):
-            tags.append("trading-volume")
-        
-        return tags
-    
-    def _extract_structured_data(self, result_text: str) -> Dict[str, Any]:
-        """Extract structured data from result text"""
-        structured = {}
-        
-        # Extract price data (simple regex matching)
-        import re
-        
-        price_matches = re.findall(r'\$([0-9,]+\.?[0-9]*)', result_text)
-        if price_matches:
-            structured["prices"] = [float(p.replace(',', '')) for p in price_matches[:5]]
-        
-        percentage_matches = re.findall(r'([+-]?[0-9]+\.?[0-9]*)%', result_text)
-        if percentage_matches:
-            structured["percentages"] = [float(p) for p in percentage_matches[:5]]
-        
-        return structured
-```
-
-## 🚀 **Deployment Configuration**
-
-### **Hugging Face Spaces Configuration**
-
-**deployment/huggingface_spaces/spaces_config.yml**
-```yaml
-title: "Web3 Research Co-Pilot"
-emoji: "🚀"
-colorFrom: "blue"
-colorTo: "purple"
-sdk: "gradio"
-sdk_version: "4.15.0"
-app_file: "app.py"
-pinned: false
-license: "mit"
-
-# Environment variables needed
-secrets:
-  - GEMINI_API_KEY
-  - ETHERSCAN_API_KEY
-  - AIRAA_WEBHOOK_URL
-  - AIRAA_API_KEY
-
-# Resource requirements
-hardware: "cpu-basic"  # Free tier
-```
-
-### **Docker Configuration** 
-**Dockerfile**
-```dockerfile
-FROM python:3.11-slim
-
-WORKDIR /app
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-# Copy requirements and install Python dependencies
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy application code
-COPY . .
-
-# Expose port
-EXPOSE 7860
-
-# Set environment variables
-ENV PYTHONPATH=/app
-ENV GRADIO_SERVER_NAME=0.0.0.0
-ENV GRADIO_SERVER_PORT=7860
-
-# Run the application
-CMD ["python", "app.py"]
-```
-
-## 📊 **Testing Strategy**
-
-### **Unit Tests**
-```python
-# tests/test_tools/test_coingecko.py
-import pytest
-import asyncio
-from src.tools.coingecko_tool import CoinGeckoTool
-
-@pytest.fixture
-def coingecko_tool():
-    return CoinGeckoTool()
-
-@pytest.mark.asyncio
-async def test_bitcoin_price_fetch(coingecko_tool):
-    result = await coingecko_tool._arun("bitcoin")
-    assert "Price:" in result
-    assert "bitcoin" in result.lower()
-
-@pytest.mark.asyncio  
-async def test_trending_coins(coingecko_tool):
-    result = await coingecko_tool._arun("trending", {"type": "trending"})
-    assert "Trending" in result
-```
-
-## 📅 **8-Day Development Timeline**
-
-### **Detailed Daily Schedule**
-
-**Days 1-2: Foundation**
-- ✅ Project structure setup
-- ✅ Configuration management
-- ✅ Base tool architecture
-- ✅ Logging and utilities
-
-**Days 3-4: Core Tools**
-- ✅ CoinGecko integration (price data)
-- ✅ DeFiLlama integration (DeFi data) 
-- ✅ Etherscan integration (on-chain data)
-- ✅ Rate limiting and error handling
-
-**Days 5-6: AI Agent**
-- ✅ LangChain agent setup
-- ✅ Query planning logic
-- ✅ Memory management
-- ✅ Response formatting
-
-**Days 7-8: UI & Deployment**
-- ✅ Gradio interface
-- ✅ AIRAA integration
-- ✅ HuggingFace Spaces deployment
-- ✅ Testing and documentation
-
-This comprehensive plan provides a production-ready Web3 research co-pilot that integrates seamlessly with AIRAA's platform while utilizing only free resources and APIs.

minimal_test.py

@@ -1,36 +0,0 @@
-import sys
-import os
-
-sys.path.insert(0, os.path.dirname(__file__))
-
-def minimal_test():
-    try:
-        print("Testing minimal imports...")
-        
-        from src.utils.config import config
-        print("✅ Config imported")
-        
-        from src.utils.logger import get_logger
-        print("✅ Logger imported")
-        
-        from src.tools.base_tool import BaseWeb3Tool
-        print("✅ Base tool imported")
-        
-        from src.tools.coingecko_tool import CoinGeckoTool
-        tool = CoinGeckoTool()
-        print("✅ CoinGecko tool created")
-        
-        from src.agent.research_agent import Web3ResearchAgent
-        print("✅ Research agent imported")
-        
-        print("🎉 All core components working!")
-        return True
-        
-    except Exception as e:
-        print(f"❌ Error: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-if __name__ == "__main__":
-    minimal_test()

requirements.txt

@@ -1,14 +1,12 @@
 langchain
 langchain-google-genai
 langchain-community
-gradio
 aiohttp
 tenacity
-plotly
-pandas
-numpy
 pydantic
 python-dotenv
 diskcache
 google-generativeai
 asyncio-throttle
+fastapi
+uvicorn

run.py

@@ -1,47 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-Web3 Research Co-Pilot Application
-Complete production-ready crypto research assistant powered by AI
-"""
-
-import sys
-import os
-import asyncio
-from pathlib import Path
-
-# Add project root to path
-project_root = Path(__file__).parent
-sys.path.insert(0, str(project_root))
-
-def main():
-    print("🚀 Starting Web3 Research Co-Pilot...")
-    
-    try:
-        from app import Web3CoPilotApp
-        
-        app = Web3CoPilotApp()
-        interface = app.create_interface()
-        
-        print("✅ Application initialized successfully!")
-        print("🌐 Launching web interface...")
-        print("📍 Local URL: http://localhost:7860")
-        
-        interface.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False,
-            show_api=False,
-            quiet=False
-        )
-        
-    except ImportError as e:
-        print(f"❌ Import error: {e}")
-        print("Please install dependencies: pip install -r requirements.txt")
-        sys.exit(1)
-    except Exception as e:
-        print(f"❌ Application error: {e}")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()

src/agent/memory_manager.py

@@ -0,0 +1,46 @@
+from langchain.memory import ConversationBufferWindowMemory
+from typing import Dict, Any, List, Optional
+
+class MemoryManager:
+    """Enhanced conversation memory management"""
+    
+    def __init__(self, window_size: int = 10):
+        self.memory = ConversationBufferWindowMemory(
+            k=window_size,
+            return_messages=True,
+            memory_key="chat_history"
+        )
+        self.context_cache: Dict[str, Any] = {}
+    
+    def add_interaction(self, query: str, response: str, metadata: Optional[Dict[str, Any]] = None):
+        """Add user interaction to memory with metadata"""
+        self.memory.save_context(
+            {"input": query},
+            {"output": response}
+        )
+        
+        if metadata:
+            self.context_cache[query[:50]] = metadata
+    
+    def get_relevant_context(self, query: str) -> Dict[str, Any]:
+        """Retrieve relevant context for current query"""
+        return {
+            "history": self.memory.load_memory_variables({}),
+            "cached_context": self._find_similar_context(query)
+        }
+    
+    def _find_similar_context(self, query: str) -> List[Dict[str, Any]]:
+        """Find contextually similar previous interactions"""
+        query_lower = query.lower()
+        relevant = []
+        
+        for cached_key, context in self.context_cache.items():
+            if any(word in cached_key.lower() for word in query_lower.split()[:3]):
+                relevant.append(context)
+        
+        return relevant[:3]
+    
+    def clear_memory(self):
+        """Clear conversation memory and cache"""
+        self.memory.clear()
+        self.context_cache.clear()

src/agent/research_agent.py

@@ -10,17 +10,24 @@ from src.tools.coingecko_tool import CoinGeckoTool
 from src.tools.defillama_tool import DeFiLlamaTool
 from src.tools.etherscan_tool import EtherscanTool
 from src.agent.query_planner import QueryPlanner
-from src.config import config
+from src.utils.config import config
 from src.utils.logger import get_logger
 
 logger = get_logger(__name__)
 
 class Web3ResearchAgent:
     def __init__(self):
+        self.llm = None
+        self.tools = []
+        self.agent = None
+        self.executor = None
+        self.enabled = False
+        
+        if not config.GEMINI_API_KEY:
+            logger.warning("GEMINI_API_KEY not configured - AI agent disabled")
+            return
+        
         try:
-            if not config.GEMINI_API_KEY:
-                raise ValueError("GEMINI_API_KEY not configured")
-            
             self.llm = ChatGoogleGenerativeAI(
                 model="gemini-1.5-flash",
                 google_api_key=config.GEMINI_API_KEY,
@@ -28,7 +35,7 @@ class Web3ResearchAgent:
                 max_tokens=2048
             )
             
-            self.tools = [CoinGeckoTool(), DeFiLlamaTool(), EtherscanTool()]
+            self.tools = self._initialize_tools()
             self.query_planner = QueryPlanner(self.llm)
             self.memory = ConversationBufferWindowMemory(
                 memory_key="chat_history", return_messages=True, k=10
@@ -39,9 +46,35 @@ class Web3ResearchAgent:
                 agent=self.agent, tools=self.tools, memory=self.memory,
                 verbose=False, max_iterations=5, handle_parsing_errors=True
             )
+            self.enabled = True
+            logger.info("Web3ResearchAgent initialized successfully")
+            
         except Exception as e:
             logger.error(f"Agent init failed: {e}")
-            raise
+            self.enabled = False
+    
+    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}")
+        
+        try:
+            tools.append(DeFiLlamaTool())
+            logger.info("DeFiLlama tool initialized")
+        except Exception as e:
+            logger.warning(f"DeFiLlama tool failed: {e}")
+        
+        try:
+            tools.append(EtherscanTool())
+            logger.info("Etherscan tool initialized")
+        except Exception as e:
+            logger.warning(f"Etherscan tool failed: {e}")
+        
+        return tools
     
     def _create_agent(self):
         prompt = ChatPromptTemplate.from_messages([
@@ -57,6 +90,16 @@ class Web3ResearchAgent:
         return create_tool_calling_agent(self.llm, self.tools, prompt)
     
     async def research_query(self, query: str) -> Dict[str, Any]:
+        if not self.enabled:
+            return {
+                "success": False,
+                "query": query,
+                "error": "AI agent not configured. Please set GEMINI_API_KEY environment variable.",
+                "result": "❌ **Service Unavailable**\n\nThe AI research agent requires a GEMINI_API_KEY to function.\n\nPlease:\n1. Get a free API key from [Google AI Studio](https://makersuite.google.com/app/apikey)\n2. Set environment variable: `export GEMINI_API_KEY='your_key'`\n3. Restart the application",
+                "sources": [],
+                "metadata": {"timestamp": datetime.now().isoformat()}
+            }
+        
         try:
             logger.info(f"Processing: {query}")
             
@@ -92,6 +135,8 @@ class Web3ResearchAgent:
                 "success": False,
                 "query": query,
                 "error": str(e),
+                "result": f"❌ **Research Error**: {str(e)}\n\nPlease try a different query or check your API configuration.",
+                "sources": [],
                 "metadata": {"timestamp": datetime.now().isoformat()}
             }
     

src/agent/response_formatter.py

@@ -0,0 +1,49 @@
+from typing import Dict, Any, Optional
+import json
+import re
+
+class ResponseFormatter:
+    """Formats AI agent responses for optimal user experience"""
+    
+    @staticmethod  
+    def format_research_response(response: str, data: Optional[Dict[str, Any]] = None) -> str:
+        """Format research response with structured data presentation"""
+        if not response:
+            return "No information available."
+        
+        formatted = response.strip()
+        
+        if data:
+            if "prices" in data:
+                formatted = ResponseFormatter._add_price_formatting(formatted, data["prices"])
+            if "metrics" in data:
+                formatted = ResponseFormatter._add_metrics_formatting(formatted, data["metrics"])
+        
+        formatted = ResponseFormatter._enhance_markdown(formatted)
+        return formatted
+    
+    @staticmethod
+    def _add_price_formatting(text: str, prices: Dict[str, float]) -> str:
+        """Add price data with formatting"""
+        price_section = "\n\n📈 **Current Prices:**\n"
+        for symbol, price in prices.items():
+            price_section += f"• **{symbol.upper()}**: ${price:,.2f}\n"
+        return text + price_section
+    
+    @staticmethod  
+    def _add_metrics_formatting(text: str, metrics: Dict[str, Any]) -> str:
+        """Add metrics with formatting"""
+        metrics_section = "\n\n📊 **Key Metrics:**\n"
+        for key, value in metrics.items():
+            if isinstance(value, (int, float)):
+                metrics_section += f"• **{key.title()}**: {value:,.2f}\n"
+            else:
+                metrics_section += f"• **{key.title()}**: {value}\n"
+        return text + metrics_section
+    
+    @staticmethod
+    def _enhance_markdown(text: str) -> str:
+        """Enhance markdown formatting for better readability"""
+        text = re.sub(r'\*\*([^*]+)\*\*', r'**\1**', text)
+        text = re.sub(r'\n\s*\n\s*\n', '\n\n', text)
+        return text.strip()

src/api/airaa_integration.py

@@ -1,7 +1,7 @@
 import aiohttp
 import re
 from typing import Dict, Any, List
-from src.config import config
+from src.utils.config import config
 from src.utils.logger import get_logger
 
 logger = get_logger(__name__)

src/api_clients.py

@@ -1,158 +0,0 @@
-import aiohttp
-import asyncio
-import time
-from typing import Dict, Any, Optional, List
-from src.config import config
-import json
-
-class RateLimiter:
-    def __init__(self, delay: float):
-        self.delay = delay
-        self.last_call = 0
-    
-    async def acquire(self):
-        now = time.time()
-        elapsed = now - self.last_call
-        if elapsed < self.delay:
-            await asyncio.sleep(self.delay - elapsed)
-        self.last_call = time.time()
-
-class CoinGeckoClient:
-    def __init__(self):
-        self.rate_limiter = RateLimiter(config.RATE_LIMIT_DELAY)
-        self.session = None
-    
-    async def get_session(self):
-        if self.session is None:
-            timeout = aiohttp.ClientTimeout(total=config.REQUEST_TIMEOUT)
-            self.session = aiohttp.ClientSession(timeout=timeout)
-        return self.session
-    
-    async def _make_request(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        await self.rate_limiter.acquire()
-        
-        url = f"{config.COINGECKO_BASE_URL}/{endpoint}"
-        if params is None:
-            params = {}
-        
-        if config.COINGECKO_API_KEY:
-            params["x_cg_demo_api_key"] = config.COINGECKO_API_KEY
-        
-        session = await self.get_session()
-        
-        for attempt in range(config.MAX_RETRIES):
-            try:
-                async with session.get(url, params=params) as response:
-                    if response.status == 200:
-                        return await response.json()
-                    elif response.status == 429:
-                        await asyncio.sleep(2 ** attempt)
-                        continue
-                    else:
-                        raise Exception(f"API error: {response.status}")
-            except asyncio.TimeoutError:
-                if attempt == config.MAX_RETRIES - 1:
-                    raise Exception("Request timeout")
-                await asyncio.sleep(1)
-        
-        raise Exception("Max retries exceeded")
-    
-    async def get_price(self, coin_ids: str, vs_currencies: str = "usd") -> Dict[str, Any]:
-        params = {
-            "ids": coin_ids,
-            "vs_currencies": vs_currencies,
-            "include_24hr_change": "true",
-            "include_24hr_vol": "true",
-            "include_market_cap": "true"
-        }
-        return await self._make_request("simple/price", params)
-    
-    async def get_trending(self) -> Dict[str, Any]:
-        return await self._make_request("search/trending")
-    
-    async def get_global_data(self) -> Dict[str, Any]:
-        return await self._make_request("global")
-    
-    async def get_coin_data(self, coin_id: str) -> Dict[str, Any]:
-        params = {"localization": "false", "tickers": "false", "community_data": "false"}
-        return await self._make_request(f"coins/{coin_id}", params)
-    
-    async def get_market_data(self, vs_currency: str = "usd", per_page: int = 10) -> Dict[str, Any]:
-        params = {
-            "vs_currency": vs_currency,
-            "order": "market_cap_desc",
-            "per_page": per_page,
-            "page": 1,
-            "sparkline": "false"
-        }
-        return await self._make_request("coins/markets", params)
-    
-    async def get_price_history(self, coin_id: str, days: int = 7) -> Dict[str, Any]:
-        params = {"vs_currency": "usd", "days": days}
-        return await self._make_request(f"coins/{coin_id}/market_chart", params)
-    
-    async def close(self):
-        if self.session:
-            await self.session.close()
-
-class CryptoCompareClient:
-    def __init__(self):
-        self.rate_limiter = RateLimiter(config.RATE_LIMIT_DELAY)
-        self.session = None
-    
-    async def get_session(self):
-        if self.session is None:
-            timeout = aiohttp.ClientTimeout(total=config.REQUEST_TIMEOUT)
-            self.session = aiohttp.ClientSession(timeout=timeout)
-        return self.session
-    
-    async def _make_request(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        await self.rate_limiter.acquire()
-        
-        url = f"{config.CRYPTOCOMPARE_BASE_URL}/{endpoint}"
-        if params is None:
-            params = {}
-        
-        if config.CRYPTOCOMPARE_API_KEY:
-            params["api_key"] = config.CRYPTOCOMPARE_API_KEY
-        
-        session = await self.get_session()
-        
-        for attempt in range(config.MAX_RETRIES):
-            try:
-                async with session.get(url, params=params) as response:
-                    if response.status == 200:
-                        data = await response.json()
-                        if data.get("Response") == "Error":
-                            raise Exception(data.get("Message", "API error"))
-                        return data
-                    elif response.status == 429:
-                        await asyncio.sleep(2 ** attempt)
-                        continue
-                    else:
-                        raise Exception(f"API error: {response.status}")
-            except asyncio.TimeoutError:
-                if attempt == config.MAX_RETRIES - 1:
-                    raise Exception("Request timeout")
-                await asyncio.sleep(1)
-        
-        raise Exception("Max retries exceeded")
-    
-    async def get_price_multi(self, fsyms: str, tsyms: str = "USD") -> Dict[str, Any]:
-        params = {"fsyms": fsyms, "tsyms": tsyms}
-        return await self._make_request("pricemulti", params)
-    
-    async def get_social_data(self, coin_symbol: str) -> Dict[str, Any]:
-        params = {"coinSymbol": coin_symbol}
-        return await self._make_request("social/coin/latest", params)
-    
-    async def get_news(self, categories: str = "blockchain") -> Dict[str, Any]:
-        params = {"categories": categories}
-        return await self._make_request("news/", params)
-    
-    async def close(self):
-        if self.session:
-            await self.session.close()
-
-coingecko_client = CoinGeckoClient()
-cryptocompare_client = CryptoCompareClient()

src/config.py

@@ -1,26 +0,0 @@
-import os
-from dataclasses import dataclass
-from typing import Optional
-
-@dataclass
-class Config:
-    GEMINI_API_KEY: str = os.getenv("GEMINI_API_KEY", "")
-    COINGECKO_API_KEY: Optional[str] = os.getenv("COINGECKO_API_KEY")
-    CRYPTOCOMPARE_API_KEY: Optional[str] = os.getenv("CRYPTOCOMPARE_API_KEY")
-    ETHERSCAN_API_KEY: str = os.getenv("ETHERSCAN_API_KEY", "")
-    
-    COINGECKO_BASE_URL: str = "https://api.coingecko.com/api/v3"
-    CRYPTOCOMPARE_BASE_URL: str = "https://min-api.cryptocompare.com/data"
-    
-    CACHE_TTL: int = 300
-    RATE_LIMIT_DELAY: float = 2.0
-    MAX_RETRIES: int = 3
-    REQUEST_TIMEOUT: int = 30
-    
-    UI_TITLE: str = "Web3 Research Co-Pilot"
-    UI_DESCRIPTION: str = "AI-powered crypto research assistant"
-    
-    AIRAA_WEBHOOK_URL: Optional[str] = os.getenv("AIRAA_WEBHOOK_URL")
-    AIRAA_API_KEY: Optional[str] = os.getenv("AIRAA_API_KEY")
-
-config = Config()

src/defillama_client.py

@@ -1,62 +0,0 @@
-import aiohttp
-import asyncio
-from typing import Dict, Any, List, Optional
-from src.config import config
-
-class DeFiLlamaClient:
-    def __init__(self):
-        self.base_url = "https://api.llama.fi"
-        self.session = None
-        self.rate_limiter = None
-    
-    async def get_session(self):
-        if self.session is None:
-            timeout = aiohttp.ClientTimeout(total=30)
-            self.session = aiohttp.ClientSession(timeout=timeout)
-        return self.session
-    
-    async def _make_request(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        url = f"{self.base_url}/{endpoint}"
-        session = await self.get_session()
-        
-        for attempt in range(3):
-            try:
-                async with session.get(url, params=params) as response:
-                    if response.status == 200:
-                        return await response.json()
-                    elif response.status == 429:
-                        await asyncio.sleep(2 ** attempt)
-                        continue
-                    else:
-                        raise Exception(f"API error: {response.status}")
-            except Exception as e:
-                if attempt == 2:
-                    raise e
-                await asyncio.sleep(1)
-    
-    async def get_protocols(self) -> List[Dict[str, Any]]:
-        return await self._make_request("protocols")
-    
-    async def get_protocol_data(self, protocol: str) -> Dict[str, Any]:
-        return await self._make_request(f"protocol/{protocol}")
-    
-    async def get_tvl_data(self) -> Dict[str, Any]:
-        return await self._make_request("v2/historicalChainTvl")
-    
-    async def get_chain_tvl(self, chain: str) -> Dict[str, Any]:
-        return await self._make_request(f"v2/historicalChainTvl/{chain}")
-    
-    async def get_yields(self) -> List[Dict[str, Any]]:
-        return await self._make_request("pools")
-    
-    async def get_bridges(self) -> List[Dict[str, Any]]:
-        return await self._make_request("bridges")
-    
-    async def get_dex_volume(self) -> Dict[str, Any]:
-        return await self._make_request("overview/dexs")
-    
-    async def close(self):
-        if self.session:
-            await self.session.close()
-
-defillama_client = DeFiLlamaClient()

src/enhanced_agent.py

@@ -1,273 +0,0 @@
-import google.generativeai as genai
-import json
-import asyncio
-from typing import Dict, Any, List, Optional
-from src.api_clients import coingecko_client, cryptocompare_client
-from src.defillama_client import defillama_client
-from src.news_aggregator import news_aggregator
-from src.cache_manager import cache_manager
-from src.config import config
-
-class EnhancedResearchAgent:
-    def __init__(self):
-        if config.GEMINI_API_KEY:
-            genai.configure(api_key=config.GEMINI_API_KEY)
-            self.model = genai.GenerativeModel('gemini-1.5-flash')
-        else:
-            self.model = None
-            
-        self.symbol_map = {
-            "btc": "bitcoin", "eth": "ethereum", "sol": "solana", "ada": "cardano",
-            "dot": "polkadot", "bnb": "binancecoin", "usdc": "usd-coin", 
-            "usdt": "tether", "xrp": "ripple", "avax": "avalanche-2",
-            "link": "chainlink", "matic": "matic-network", "uni": "uniswap",
-            "atom": "cosmos", "near": "near", "icp": "internet-computer",
-            "ftm": "fantom", "algo": "algorand", "xlm": "stellar"
-        }
-    
-    def _format_coin_id(self, symbol: str) -> str:
-        return self.symbol_map.get(symbol.lower(), symbol.lower())
-    
-    async def get_comprehensive_market_data(self) -> Dict[str, Any]:
-        cache_key = "comprehensive_market"
-        cached = cache_manager.get(cache_key)
-        if cached:
-            return cached
-        
-        try:
-            tasks = [
-                coingecko_client.get_market_data(per_page=50),
-                coingecko_client.get_global_data(),
-                coingecko_client.get_trending(),
-                defillama_client.get_protocols(),
-                defillama_client.get_tvl_data(),
-                news_aggregator.get_crypto_news(5)
-            ]
-            
-            results = await asyncio.gather(*tasks, return_exceptions=True)
-            
-            data = {}
-            for i, result in enumerate(results):
-                if not isinstance(result, Exception):
-                    if i == 0: data["market_data"] = result
-                    elif i == 1: data["global_data"] = result
-                    elif i == 2: data["trending"] = result
-                    elif i == 3: 
-                        data["defi_protocols"] = result[:20] if isinstance(result, list) and result else []
-                    elif i == 4: data["tvl_data"] = result
-                    elif i == 5: data["news"] = result
-            
-            cache_manager.set(cache_key, data, 180)
-            return data
-            
-        except Exception as e:
-            raise Exception(f"Failed to fetch comprehensive market data: {str(e)}")
-    
-    async def get_defi_analysis(self, protocol: Optional[str] = None) -> Dict[str, Any]:
-        cache_key = f"defi_analysis_{protocol or 'overview'}"
-        cached = cache_manager.get(cache_key)
-        if cached:
-            return cached
-        
-        try:
-            if protocol:
-                data = await defillama_client.get_protocol_data(protocol)
-            else:
-                protocols = await defillama_client.get_protocols()
-                tvl_data = await defillama_client.get_tvl_data()
-                yields_data = await defillama_client.get_yields()
-                
-                data = {
-                    "top_protocols": protocols[:20] if isinstance(protocols, list) and protocols else [],
-                    "tvl_overview": tvl_data,
-                    "top_yields": yields_data[:10] if isinstance(yields_data, list) and yields_data else []
-                }
-            
-            cache_manager.set(cache_key, data, 300)
-            return data
-            
-        except Exception as e:
-            raise Exception(f"Failed to get DeFi analysis: {str(e)}")
-    
-    async def get_price_history(self, symbol: str, days: int = 30) -> Dict[str, Any]:
-        cache_key = f"price_history_{symbol}_{days}"
-        cached = cache_manager.get(cache_key)
-        if cached:
-            return cached
-        
-        try:
-            coin_id = self._format_coin_id(symbol)
-            data = await coingecko_client.get_price_history(coin_id, days)
-            cache_manager.set(cache_key, data, 900)
-            return data
-        except Exception as e:
-            raise Exception(f"Failed to get price history for {symbol}: {str(e)}")
-    
-    async def get_advanced_coin_analysis(self, symbol: str) -> Dict[str, Any]:
-        cache_key = f"advanced_analysis_{symbol.lower()}"
-        cached = cache_manager.get(cache_key)
-        if cached:
-            return cached
-        
-        try:
-            coin_id = self._format_coin_id(symbol)
-            
-            tasks = [
-                coingecko_client.get_coin_data(coin_id),
-                coingecko_client.get_price_history(coin_id, days=30),
-                cryptocompare_client.get_social_data(symbol.upper()),
-                self._get_defi_involvement(symbol.upper())
-            ]
-            
-            results = await asyncio.gather(*tasks, return_exceptions=True)
-            
-            analysis = {}
-            for i, result in enumerate(results):
-                if not isinstance(result, Exception):
-                    if i == 0: analysis["coin_data"] = result
-                    elif i == 1: analysis["price_history"] = result
-                    elif i == 2: analysis["social_data"] = result
-                    elif i == 3: analysis["defi_data"] = result
-            
-            cache_manager.set(cache_key, analysis, 300)
-            return analysis
-            
-        except Exception as e:
-            raise Exception(f"Failed advanced analysis for {symbol}: {str(e)}")
-    
-    async def _get_defi_involvement(self, symbol: str) -> Dict[str, Any]:
-        try:
-            protocols = await defillama_client.get_protocols()
-            if protocols:
-                relevant_protocols = [p for p in protocols if symbol.lower() in p.get("name", "").lower()]
-                return {"protocols": relevant_protocols[:5]}
-            return {"protocols": []}
-        except:
-            return {"protocols": []}
-    
-    def _format_comprehensive_data(self, data: Dict[str, Any]) -> str:
-        formatted = "📊 COMPREHENSIVE CRYPTO MARKET ANALYSIS\n\n"
-        
-        if "global_data" in data and data["global_data"].get("data"):
-            global_info = data["global_data"]["data"]
-            total_mcap = global_info.get("total_market_cap", {}).get("usd", 0)
-            total_volume = global_info.get("total_volume", {}).get("usd", 0)
-            btc_dominance = global_info.get("market_cap_percentage", {}).get("btc", 0)
-            eth_dominance = global_info.get("market_cap_percentage", {}).get("eth", 0)
-            
-            formatted += f"💰 Total Market Cap: ${total_mcap/1e12:.2f}T\n"
-            formatted += f"📈 24h Volume: ${total_volume/1e9:.1f}B\n"
-            formatted += f"₿ Bitcoin Dominance: {btc_dominance:.1f}%\n"
-            formatted += f"Ξ Ethereum Dominance: {eth_dominance:.1f}%\n\n"
-        
-        if "trending" in data and data["trending"].get("coins"):
-            formatted += "🔥 TRENDING CRYPTOCURRENCIES\n"
-            for i, coin in enumerate(data["trending"]["coins"][:5], 1):
-                name = coin.get("item", {}).get("name", "Unknown")
-                symbol = coin.get("item", {}).get("symbol", "")
-                score = coin.get("item", {}).get("score", 0)
-                formatted += f"{i}. {name} ({symbol.upper()}) - Score: {score}\n"
-            formatted += "\n"
-        
-        if "defi_protocols" in data and data["defi_protocols"]:
-            formatted += "🏦 TOP DeFi PROTOCOLS\n"
-            for i, protocol in enumerate(data["defi_protocols"][:5], 1):
-                name = protocol.get("name", "Unknown")
-                tvl = protocol.get("tvl", 0)
-                chain = protocol.get("chain", "Unknown")
-                formatted += f"{i}. {name} ({chain}): ${tvl/1e9:.2f}B TVL\n"
-            formatted += "\n"
-        
-        if "news" in data and data["news"]:
-            formatted += "📰 LATEST CRYPTO NEWS\n"
-            for i, article in enumerate(data["news"][:3], 1):
-                title = article.get("title", "No title")[:60] + "..."
-                source = article.get("source", "Unknown")
-                formatted += f"{i}. {title} - {source}\n"
-            formatted += "\n"
-        
-        if "market_data" in data and data["market_data"]:
-            formatted += "💎 TOP PERFORMING COINS (24h)\n"
-            valid_coins = [coin for coin in data["market_data"][:20] if coin.get("price_change_percentage_24h") is not None]
-            sorted_coins = sorted(valid_coins, key=lambda x: x.get("price_change_percentage_24h", 0), reverse=True)
-            for i, coin in enumerate(sorted_coins[:5], 1):
-                name = coin.get("name", "Unknown")
-                symbol = coin.get("symbol", "").upper()
-                price = coin.get("current_price", 0)
-                change = coin.get("price_change_percentage_24h", 0)
-                formatted += f"{i}. {name} ({symbol}): ${price:,.4f} (+{change:.2f}%)\n"
-        
-        return formatted
-    
-    async def research_with_context(self, query: str) -> str:
-        try:
-            if not config.GEMINI_API_KEY or not self.model:
-                return "❌ Gemini API key not configured. Please set GEMINI_API_KEY environment variable."
-            
-            system_prompt = """You are an advanced Web3 and DeFi research analyst with access to real-time market data, 
-            DeFi protocol information, social sentiment, and breaking news. Provide comprehensive, actionable insights 
-            that combine multiple data sources for superior analysis.
-            
-            Guidelines:
-            - Synthesize data from multiple sources (price, DeFi, social, news)
-            - Provide specific recommendations with risk assessments
-            - Include both technical and fundamental analysis
-            - Reference current market conditions and news events
-            - Use clear, professional language with data-driven insights
-            - Highlight opportunities and risks clearly
-            """
-            
-            market_context = ""
-            try:
-                if any(keyword in query.lower() for keyword in 
-                       ["market", "overview", "analysis", "trending", "defi", "protocols"]):
-                    comprehensive_data = await self.get_comprehensive_market_data()
-                    market_context = f"\n\nCURRENT MARKET ANALYSIS:\n{self._format_comprehensive_data(comprehensive_data)}"
-                
-                for symbol in self.symbol_map.keys():
-                    if symbol in query.lower() or symbol.upper() in query:
-                        analysis_data = await self.get_advanced_coin_analysis(symbol)
-                        if "coin_data" in analysis_data:
-                            coin_info = analysis_data["coin_data"]
-                            market_data = coin_info.get("market_data", {})
-                            current_price = market_data.get("current_price", {}).get("usd", 0)
-                            price_change = market_data.get("price_change_percentage_24h", 0)
-                            market_cap = market_data.get("market_cap", {}).get("usd", 0)
-                            volume = market_data.get("total_volume", {}).get("usd", 0)
-                            ath = market_data.get("ath", {}).get("usd", 0)
-                            ath_change = market_data.get("ath_change_percentage", {}).get("usd", 0)
-                            
-                            market_context += f"\n\n{symbol.upper()} DETAILED ANALYSIS:\n"
-                            market_context += f"Current Price: ${current_price:,.4f}\n"
-                            market_context += f"24h Change: {price_change:+.2f}%\n"
-                            market_context += f"Market Cap: ${market_cap/1e9:.2f}B\n"
-                            market_context += f"24h Volume: ${volume/1e9:.2f}B\n"
-                            market_context += f"ATH: ${ath:,.4f} ({ath_change:+.2f}% from ATH)\n"
-                        break
-                
-                if "defi" in query.lower():
-                    defi_data = await self.get_defi_analysis()
-                    if "top_protocols" in defi_data and defi_data["top_protocols"]:
-                        market_context += "\n\nTOP DeFi PROTOCOLS BY TVL:\n"
-                        for protocol in defi_data["top_protocols"][:5]:
-                            name = protocol.get("name", "Unknown")
-                            tvl = protocol.get("tvl", 0)
-                            change = protocol.get("change_1d", 0)
-                            market_context += f"• {name}: ${tvl/1e9:.2f}B TVL ({change:+.2f}%)\n"
-                
-            except Exception as e:
-                market_context = f"\n\nNote: Some enhanced data unavailable ({str(e)})"
-            
-            full_prompt = f"{system_prompt}\n\nQuery: {query}\n\nReal-time Market Context:{market_context}"
-            
-            response = self.model.generate_content(full_prompt)
-            return response.text if response.text else "❌ No response generated. Please try rephrasing your query."
-            
-        except Exception as e:
-            return f"❌ Enhanced research failed: {str(e)}"
-    
-    async def close(self):
-        await coingecko_client.close()
-        await cryptocompare_client.close()
-        await defillama_client.close()
-        await news_aggregator.close()

src/news_aggregator.py

@@ -1,83 +0,0 @@
-import aiohttp
-import asyncio
-from typing import Dict, Any, List, Optional
-from datetime import datetime
-import json
-
-class CryptoNewsAggregator:
-    def __init__(self):
-        self.sources = {
-            "cryptonews": "https://cryptonews-api.com/api/v1/category?section=general&items=10",
-            "newsapi": "https://newsapi.org/v2/everything?q=cryptocurrency&sortBy=publishedAt&pageSize=10",
-            "coindesk": "https://api.coindesk.com/v1/news/articles"
-        }
-        self.session = None
-    
-    async def get_session(self):
-        if self.session is None:
-            timeout = aiohttp.ClientTimeout(total=30)
-            headers = {"User-Agent": "Web3-Research-CoBot/1.0"}
-            self.session = aiohttp.ClientSession(timeout=timeout, headers=headers)
-        return self.session
-    
-    async def get_crypto_news(self, limit: int = 10) -> List[Dict[str, Any]]:
-        news_items = []
-        tasks = []
-        
-        for source, url in self.sources.items():
-            tasks.append(self._fetch_news_from_source(source, url))
-        
-        results = await asyncio.gather(*tasks, return_exceptions=True)
-        
-        for result in results:
-            if not isinstance(result, Exception) and result:
-                news_items.extend(result[:5])
-        
-        news_items.sort(key=lambda x: x.get("timestamp", 0), reverse=True)
-        return news_items[:limit]
-    
-    async def _fetch_news_from_source(self, source: str, url: str) -> List[Dict[str, Any]]:
-        try:
-            session = await self.get_session()
-            async with session.get(url) as response:
-                if response.status == 200:
-                    data = await response.json()
-                    return self._parse_news_data(source, data)
-                return []
-        except Exception:
-            return []
-    
-    def _parse_news_data(self, source: str, data: Dict[str, Any]) -> List[Dict[str, Any]]:
-        news_items = []
-        current_time = datetime.now().timestamp()
-        
-        try:
-            if source == "cryptonews" and "data" in data:
-                for item in data["data"][:5]:
-                    news_items.append({
-                        "title": item.get("news_title", ""),
-                        "summary": item.get("text", "")[:200] + "...",
-                        "url": item.get("news_url", ""),
-                        "source": "CryptoNews",
-                        "timestamp": current_time
-                    })
-            
-            elif source == "newsapi" and "articles" in data:
-                for item in data["articles"][:5]:
-                    news_items.append({
-                        "title": item.get("title", ""),
-                        "summary": item.get("description", "")[:200] + "...",
-                        "url": item.get("url", ""),
-                        "source": item.get("source", {}).get("name", "NewsAPI"),
-                        "timestamp": current_time
-                    })
-        except Exception:
-            pass
-        
-        return news_items
-    
-    async def close(self):
-        if self.session:
-            await self.session.close()
-
-news_aggregator = CryptoNewsAggregator()

src/portfolio_analyzer.py

@@ -1,143 +0,0 @@
-import asyncio
-from typing import Dict, Any, List, Optional
-from src.api_clients import coingecko_client
-from src.cache_manager import cache_manager
-import json
-
-class PortfolioAnalyzer:
-    def __init__(self):
-        self.symbol_map = {
-            "btc": "bitcoin", "eth": "ethereum", "sol": "solana", "ada": "cardano",
-            "dot": "polkadot", "bnb": "binancecoin", "usdc": "usd-coin", 
-            "usdt": "tether", "xrp": "ripple", "avax": "avalanche-2",
-            "link": "chainlink", "matic": "matic-network", "uni": "uniswap"
-        }
-    
-    def _format_coin_id(self, symbol: str) -> str:
-        return self.symbol_map.get(symbol.lower(), symbol.lower())
-    
-    async def analyze_portfolio(self, holdings: List[Dict[str, Any]]) -> Dict[str, Any]:
-        try:
-            coin_ids = [self._format_coin_id(h["symbol"]) for h in holdings]
-            
-            tasks = []
-            for coin_id in coin_ids:
-                tasks.append(coingecko_client.get_coin_data(coin_id))
-                tasks.append(coingecko_client.get_price_history(coin_id, days=30))
-            
-            results = await asyncio.gather(*tasks, return_exceptions=True)
-            
-            portfolio_value = 0
-            portfolio_change_24h = 0
-            asset_allocation = []
-            risk_metrics = []
-            
-            for i, holding in enumerate(holdings):
-                coin_data_idx = i * 2
-                price_history_idx = i * 2 + 1
-                
-                if not isinstance(results[coin_data_idx], Exception):
-                    coin_data = results[coin_data_idx]
-                    market_data = coin_data.get("market_data", {})
-                    current_price = market_data.get("current_price", {}).get("usd", 0)
-                    price_change_24h = market_data.get("price_change_percentage_24h", 0)
-                    
-                    holding_value = current_price * holding["amount"]
-                    portfolio_value += holding_value
-                    portfolio_change_24h += holding_value * (price_change_24h / 100)
-                    
-                    volatility = 0
-                    if not isinstance(results[price_history_idx], Exception):
-                        price_history = results[price_history_idx]
-                        prices = [p[1] for p in price_history.get("prices", [])]
-                        if len(prices) > 1:
-                            price_changes = [(prices[i] - prices[i-1]) / prices[i-1] for i in range(1, len(prices))]
-                            volatility = sum(abs(change) for change in price_changes) / len(price_changes)
-                    
-                    asset_allocation.append({
-                        "symbol": holding["symbol"].upper(),
-                        "name": coin_data.get("name", "Unknown"),
-                        "value": holding_value,
-                        "percentage": 0,
-                        "amount": holding["amount"],
-                        "price": current_price,
-                        "change_24h": price_change_24h
-                    })
-                    
-                    risk_metrics.append({
-                        "symbol": holding["symbol"].upper(),
-                        "volatility": volatility,
-                        "market_cap_rank": coin_data.get("market_cap_rank", 999)
-                    })
-            
-            for asset in asset_allocation:
-                asset["percentage"] = (asset["value"] / portfolio_value) * 100 if portfolio_value > 0 else 0
-            
-            portfolio_change_percentage = (portfolio_change_24h / portfolio_value) * 100 if portfolio_value > 0 else 0
-            
-            avg_volatility = sum(r["volatility"] for r in risk_metrics) / len(risk_metrics) if risk_metrics else 0
-            
-            diversification_score = len([a for a in asset_allocation if a["percentage"] >= 5])
-            
-            risk_level = "Low" if avg_volatility < 0.05 else "Medium" if avg_volatility < 0.10 else "High"
-            
-            return {
-                "total_value": portfolio_value,
-                "change_24h": portfolio_change_24h,
-                "change_24h_percentage": portfolio_change_percentage,
-                "asset_allocation": sorted(asset_allocation, key=lambda x: x["value"], reverse=True),
-                "risk_metrics": {
-                    "overall_risk": risk_level,
-                    "avg_volatility": avg_volatility,
-                    "diversification_score": diversification_score,
-                    "largest_holding_percentage": max([a["percentage"] for a in asset_allocation]) if asset_allocation else 0
-                },
-                "recommendations": self._generate_recommendations(asset_allocation, risk_metrics)
-            }
-            
-        except Exception as e:
-            raise Exception(f"Portfolio analysis failed: {str(e)}")
-    
-    def _generate_recommendations(self, allocation: List[Dict[str, Any]], risk_metrics: List[Dict[str, Any]]) -> List[str]:
-        recommendations = []
-        
-        if not allocation:
-            return ["Unable to generate recommendations - no valid portfolio data"]
-        
-        largest_holding = max(allocation, key=lambda x: x["percentage"])
-        if largest_holding["percentage"] > 50:
-            recommendations.append(f"Consider reducing {largest_holding['symbol']} position (currently {largest_holding['percentage']:.1f}%) to improve diversification")
-        
-        high_risk_assets = [r for r in risk_metrics if r["volatility"] > 0.15]
-        if len(high_risk_assets) > len(allocation) * 0.6:
-            recommendations.append("Portfolio has high volatility exposure - consider adding stable assets like BTC or ETH")
-        
-        small_cap_heavy = len([r for r in risk_metrics if r["market_cap_rank"] > 100])
-        if small_cap_heavy > len(allocation) * 0.4:
-            recommendations.append("High small-cap exposure detected - consider balancing with top 20 cryptocurrencies")
-        
-        if len(allocation) < 5:
-            recommendations.append("Consider diversifying into 5-10 different cryptocurrencies to reduce risk")
-        
-        stablecoin_exposure = sum(a["percentage"] for a in allocation if a["symbol"] in ["USDC", "USDT", "DAI"])
-        if stablecoin_exposure < 10:
-            recommendations.append("Consider allocating 10-20% to stablecoins for portfolio stability")
-        
-        return recommendations[:5]
-    
-    async def compare_portfolios(self, portfolio1: List[Dict[str, Any]], portfolio2: List[Dict[str, Any]]) -> Dict[str, Any]:
-        analysis1 = await self.analyze_portfolio(portfolio1)
-        analysis2 = await self.analyze_portfolio(portfolio2)
-        
-        return {
-            "portfolio_1": analysis1,
-            "portfolio_2": analysis2,
-            "comparison": {
-                "value_difference": analysis2["total_value"] - analysis1["total_value"],
-                "performance_difference": analysis2["change_24h_percentage"] - analysis1["change_24h_percentage"],
-                "risk_comparison": f"Portfolio 2 is {'higher' if analysis2['risk_metrics']['avg_volatility'] > analysis1['risk_metrics']['avg_volatility'] else 'lower'} risk",
-                "diversification_comparison": f"Portfolio 2 is {'more' if analysis2['risk_metrics']['diversification_score'] > analysis1['risk_metrics']['diversification_score'] else 'less'} diversified"
-            }
-        }
-
-portfolio_analyzer = PortfolioAnalyzer()

src/research_agent.py

@@ -1,201 +0,0 @@
-from google import genai
-from google.genai import types
-import json
-from typing import Dict, Any, List
-from src.api_clients import coingecko_client, cryptocompare_client
-from src.cache_manager import cache_manager
-from src.config import config
-import asyncio
-
-class ResearchAgent:
-    def __init__(self):
-        self.client = genai.Client(api_key=config.GEMINI_API_KEY)
-        self.symbol_map = {
-            "btc": "bitcoin", "eth": "ethereum", "sol": "solana",
-            "ada": "cardano", "dot": "polkadot", "bnb": "binancecoin",
-            "usdc": "usd-coin", "usdt": "tether", "xrp": "ripple",
-            "avax": "avalanche-2", "link": "chainlink", "matic": "matic-network"
-        }
-    
-    def _format_coin_id(self, symbol: str) -> str:
-        return self.symbol_map.get(symbol.lower(), symbol.lower())
-    
-    async def get_market_overview(self) -> Dict[str, Any]:
-        cache_key = "market_overview"
-        cached = cache_manager.get(cache_key)
-        if cached:
-            return cached
-        
-        try:
-            market_data = await coingecko_client.get_market_data(per_page=20)
-            global_data = await coingecko_client.get_global_data()
-            trending = await coingecko_client.get_trending()
-            
-            result = {
-                "market_data": market_data,
-                "global_data": global_data,
-                "trending": trending
-            }
-            
-            cache_manager.set(cache_key, result)
-            return result
-            
-        except Exception as e:
-            raise Exception(f"Failed to fetch market overview: {str(e)}")
-    
-    async def get_price_history(self, symbol: str) -> Dict[str, Any]:
-        cache_key = f"price_history_{symbol.lower()}"
-        cached = cache_manager.get(cache_key)
-        if cached:
-            return cached
-        
-        try:
-            coin_id = self._format_coin_id(symbol)
-            data = await coingecko_client.get_price_history(coin_id, days=30)
-            
-            cache_manager.set(cache_key, data)
-            return data
-            
-        except Exception as e:
-            raise Exception(f"Failed to fetch price history for {symbol}: {str(e)}")
-    
-    async def get_coin_analysis(self, symbol: str) -> Dict[str, Any]:
-        cache_key = f"coin_analysis_{symbol.lower()}"
-        cached = cache_manager.get(cache_key)
-        if cached:
-            return cached
-        
-        try:
-            coin_id = self._format_coin_id(symbol)
-            
-            tasks = [
-                coingecko_client.get_coin_data(coin_id),
-                coingecko_client.get_price_history(coin_id, days=7),
-                cryptocompare_client.get_social_data(symbol.upper())
-            ]
-            
-            coin_data, price_history, social_data = await asyncio.gather(*tasks, return_exceptions=True)
-            
-            result = {}
-            if not isinstance(coin_data, Exception):
-                result["coin_data"] = coin_data
-            if not isinstance(price_history, Exception):
-                result["price_history"] = price_history
-            if not isinstance(social_data, Exception):
-                result["social_data"] = social_data
-            
-            cache_manager.set(cache_key, result)
-            return result
-            
-        except Exception as e:
-            raise Exception(f"Failed to analyze {symbol}: {str(e)}")
-    
-    def _format_market_data(self, data: Dict[str, Any]) -> str:
-        if not data:
-            return "No market data available"
-        
-        formatted = "📊 MARKET OVERVIEW\n\n"
-        
-        if "global_data" in data and "data" in data["global_data"]:
-            global_info = data["global_data"]["data"]
-            total_mcap = global_info.get("total_market_cap", {}).get("usd", 0)
-            total_volume = global_info.get("total_volume", {}).get("usd", 0)
-            btc_dominance = global_info.get("market_cap_percentage", {}).get("btc", 0)
-            
-            formatted += f"Total Market Cap: ${total_mcap:,.0f}\n"
-            formatted += f"24h Volume: ${total_volume:,.0f}\n"
-            formatted += f"Bitcoin Dominance: {btc_dominance:.1f}%\n\n"
-        
-        if "trending" in data and "coins" in data["trending"]:
-            formatted += "🔥 TRENDING COINS\n"
-            for i, coin in enumerate(data["trending"]["coins"][:5], 1):
-                name = coin.get("item", {}).get("name", "Unknown")
-                symbol = coin.get("item", {}).get("symbol", "")
-                formatted += f"{i}. {name} ({symbol.upper()})\n"
-            formatted += "\n"
-        
-        if "market_data" in data:
-            formatted += "💰 TOP CRYPTOCURRENCIES\n"
-            for i, coin in enumerate(data["market_data"][:10], 1):
-                name = coin.get("name", "Unknown")
-                symbol = coin.get("symbol", "").upper()
-                price = coin.get("current_price", 0)
-                change = coin.get("price_change_percentage_24h", 0)
-                change_symbol = "📈" if change >= 0 else "📉"
-                
-                formatted += f"{i:2d}. {name} ({symbol}): ${price:,.4f} {change_symbol} {change:+.2f}%\n"
-        
-        return formatted
-    
-    async def research(self, query: str) -> str:
-        try:
-            if not config.GEMINI_API_KEY:
-                return "❌ Gemini API key not configured. Please set GEMINI_API_KEY environment variable."
-            
-            system_prompt = """You are an expert Web3 and cryptocurrency research analyst. 
-            Provide comprehensive, accurate, and actionable insights based on real market data.
-            
-            Guidelines:
-            - Give specific, data-driven analysis
-            - Include price targets and risk assessments when relevant
-            - Explain technical concepts clearly
-            - Provide actionable recommendations
-            - Use emojis for better readability
-            - Be concise but thorough
-            """
-            
-            market_context = ""
-            try:
-                if any(keyword in query.lower() for keyword in ["market", "overview", "trending", "top"]):
-                    market_data = await self.get_market_overview()
-                    market_context = f"\n\nCURRENT MARKET DATA:\n{self._format_market_data(market_data)}"
-                
-                for symbol in ["btc", "eth", "sol", "ada", "dot", "bnb", "avax", "link"]:
-                    if symbol in query.lower() or symbol.upper() in query:
-                        analysis_data = await self.get_coin_analysis(symbol)
-                        if "coin_data" in analysis_data:
-                            coin_info = analysis_data["coin_data"]
-                            market_data = coin_info.get("market_data", {})
-                            current_price = market_data.get("current_price", {}).get("usd", 0)
-                            price_change = market_data.get("price_change_percentage_24h", 0)
-                            market_cap = market_data.get("market_cap", {}).get("usd", 0)
-                            volume = market_data.get("total_volume", {}).get("usd", 0)
-                            
-                            market_context += f"\n\n{symbol.upper()} DATA:\n"
-                            market_context += f"Price: ${current_price:,.4f}\n"
-                            market_context += f"24h Change: {price_change:+.2f}%\n"
-                            market_context += f"Market Cap: ${market_cap:,.0f}\n"
-                            market_context += f"Volume: ${volume:,.0f}\n"
-                        break
-                
-            except Exception as e:
-                market_context = f"\n\nNote: Some market data unavailable ({str(e)})"
-            
-            full_prompt = f"{query}{market_context}"
-            
-            response = self.client.models.generate_content(
-                model="gemini-2.5-flash",
-                contents=[
-                    types.Content(
-                        role="user", 
-                        parts=[types.Part(text=full_prompt)]
-                    )
-                ],
-                config=types.GenerateContentConfig(
-                    system_instruction=system_prompt,
-                    temperature=0.3,
-                    max_output_tokens=2000
-                )
-            )
-            
-            if response.text:
-                return response.text
-            else:
-                return "❌ No response generated. Please try rephrasing your query."
-                
-        except Exception as e:
-            return f"❌ Research failed: {str(e)}"
-    
-    async def close(self):
-        await coingecko_client.close()
-        await cryptocompare_client.close()

src/tools/base_tool.py

@@ -4,8 +4,11 @@ from langchain.tools import BaseTool
 from pydantic import BaseModel, Field, PrivateAttr
 import asyncio
 import aiohttp
+import hashlib
+import json
 from tenacity import retry, stop_after_attempt, wait_exponential
 from src.utils.logger import get_logger
+from src.utils.cache_manager import cache_manager
 
 logger = get_logger(__name__)
 
@@ -32,11 +35,25 @@ class BaseWeb3Tool(BaseTool, ABC):
     
     @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=8))
     async def make_request(self, url: str, params: Dict[str, Any] = None) -> Dict[str, Any]:
+        # Create cache key
+        cache_key = self._create_cache_key(url, params or {})
+        
+        # Check cache first
+        cached_result = cache_manager.get(cache_key)
+        if cached_result is not None:
+            logger.debug(f"Cache hit for {url}")
+            return cached_result
+        
+        logger.debug(f"Cache miss for {url}")
         session = await self.get_session()
+        
         try:
             async with session.get(url, params=params or {}) as response:
                 if response.status == 200:
-                    return await response.json()
+                    result = await response.json()
+                    # Cache successful responses for 5 minutes
+                    cache_manager.set(cache_key, result, ttl=300)
+                    return result
                 elif response.status == 429:
                     await asyncio.sleep(2)
                     raise aiohttp.ClientResponseError(
@@ -50,6 +67,11 @@ class BaseWeb3Tool(BaseTool, ABC):
             logger.error(f"Request failed: {e}")
             raise
     
+    def _create_cache_key(self, url: str, params: Dict[str, Any]) -> str:
+        """Create a unique cache key from URL and parameters"""
+        key_data = f"{url}:{json.dumps(params, sort_keys=True)}"
+        return hashlib.md5(key_data.encode()).hexdigest()[:16]
+    
     def _run(self, query: str, filters: Optional[Dict[str, Any]] = None) -> str:
         return asyncio.run(self._arun(query, filters))
     
@@ -60,5 +82,4 @@ class BaseWeb3Tool(BaseTool, ABC):
     async def cleanup(self):
         if self._session:
             await self._session.close()
-        if self.session:
-            await self.session.close()
+            self._session = None

src/tools/coingecko_tool.py

@@ -2,77 +2,119 @@ from typing import Dict, Any, Optional
 from pydantic import BaseModel, PrivateAttr
 from src.tools.base_tool import BaseWeb3Tool, Web3ToolInput
 from src.utils.config import config
+from src.utils.logger import get_logger
+from src.utils.cache_manager import cache_manager
+
+logger = get_logger(__name__)
 
 class CoinGeckoTool(BaseWeb3Tool):
     name: str = "coingecko_data"
-    description: str = """Get cryptocurrency price, volume, market cap and trend data from CoinGecko.
-    Useful for: price analysis, market rankings, volume trends, price changes.
-    Input: cryptocurrency name/symbol (bitcoin, ethereum, BTC, ETH) or market query."""
+    description: str = """Get cryptocurrency price, volume, market cap and trend data from CoinGecko."""
     args_schema: type[BaseModel] = Web3ToolInput
-    
+
     _base_url: str = PrivateAttr(default="https://api.coingecko.com/api/v3")
     _symbol_map: Dict[str, str] = PrivateAttr(default_factory=lambda: {
         "btc": "bitcoin", "eth": "ethereum", "sol": "solana", "ada": "cardano",
-        "dot": "polkadot", "bnb": "binancecoin", "usdc": "usd-coin", 
+        "dot": "polkadot", "bnb": "binancecoin", "usdc": "usd-coin",
         "usdt": "tether", "xrp": "ripple", "avax": "avalanche-2",
         "link": "chainlink", "matic": "matic-network", "uni": "uniswap"
     })
-    
+
     def __init__(self):
         super().__init__()
-    
+
     async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None) -> str:
+        filters = filters or {}
         try:
-            filters = filters or {}
-            
-            if filters.get("type") == "trending":
-                return await self._get_trending()
-            elif filters.get("type") == "market_overview":
-                return await self._get_market_overview()
-            elif filters.get("type") == "price_history":
-                return await self._get_price_history(query, filters.get("days", 30))
+            # Check cache first
+            cache_key = f"coingecko_{filters.get('type', 'coin')}_{query}_{str(filters)}"
+            cached_result = cache_manager.get(cache_key)
+            if cached_result:
+                logger.info(f"Cache hit for {cache_key}")
+                return cached_result
+            
+            result = None
+            t = filters.get("type")
+            
+            if t == "trending":
+                result = await self._get_trending()
+            elif t == "market_overview":
+                result = await self._get_market_overview()
+            elif t == "price_history":
+                days = int(filters.get("days", 30))
+                result = await self._get_price_history(query, days)
             else:
-                return await self._get_coin_data(query)
-                
+                result = await self._get_coin_data(query)
+            
+            # Cache successful results
+            if result and not result.startswith("⚠️"):
+                cache_manager.set(cache_key, result, ttl=300)
+            
+            return result
+            
         except Exception as e:
-            return f"CoinGecko error: {str(e)}"
+            logger.error(f"CoinGecko error: {e}")
+            return f"⚠️ CoinGecko service temporarily unavailable: {str(e)}"
+
     async def _get_trending(self) -> str:
         data = await self.make_request(f"{self._base_url}/search/trending")
-        data = await self.make_request(f"{self.base_url}/search/trending")
-        
-        trending = data.get("coins", [])[:5]
-        result = "🔥 **Trending Cryptocurrencies:**\n\n"
-        
-        for i, coin in enumerate(trending, 1):
-            item = coin.get("item", {})
-            name = item.get("name", "Unknown")
-            symbol = item.get("symbol", "").upper()
-            rank = item.get("market_cap_rank", "N/A")
-            result += f"{i}. **{name} ({symbol})** - Rank #{rank}\n"
-        
-        return result
-    
+        coins = data.get("coins", [])[:5]
+        out = "🔥 **Trending Cryptocurrencies:**\n\n"
+        for i, c in enumerate(coins, 1):
+            item = c.get("item", {})
+            out += f"{i}. **{item.get('name','?')} ({item.get('symbol','?').upper()})** – Rank #{item.get('market_cap_rank','?')}\n"
+        return out
+
     async def _get_market_overview(self) -> str:
-        data = await self.make_request(f"{self._base_url}/coins/markets", params)10, "page": 1}
-        data = await self.make_request(f"{self.base_url}/coins/markets", params)
-        
-        result = "📊 **Top Cryptocurrencies by Market Cap:**\n\n"
-        
-        for coin in data[:10]:
-            name = coin.get("name", "Unknown")
-            symbol = coin.get("symbol", "").upper()
-            price = coin.get("current_price", 0)
-            change = coin.get("price_change_percentage_24h", 0)
-            mcap = coin.get("market_cap", 0)
-            
-            emoji = "📈" if change >= 0 else "📉"
-            result += f"{emoji} **{name} ({symbol})**: ${price:,.4f} ({change:+.2f}%) | MCap: ${mcap/1e9:.2f}B\n"
+        try:
+            params = {
+                "vs_currency": "usd",
+                "order": "market_cap_desc",
+                "per_page": 10,
+                "page": 1
+            }
+            data = await self.make_request(f"{self._base_url}/coins/markets", params=params)
+            
+            if not data or not isinstance(data, list):
+                return "⚠️ Market overview data temporarily unavailable"
+            
+            if len(data) == 0:
+                return "❌ No market data available"
+            
+            result = "📊 **Top Cryptocurrencies by Market Cap:**\n\n"
+            
+            for coin in data[:10]:  # Ensure max 10
+                try:
+                    name = coin.get("name", "Unknown")
+                    symbol = coin.get("symbol", "?").upper()
+                    price = coin.get("current_price", 0)
+                    change_24h = coin.get("price_change_percentage_24h", 0)
+                    market_cap = coin.get("market_cap", 0)
+                    
+                    # Handle missing or invalid data
+                    if price is None or price <= 0:
+                        continue
+                    
+                    emoji = "📈" if change_24h >= 0 else "📉"
+                    mcap_formatted = f"${market_cap/1e9:.2f}B" if market_cap > 0 else "N/A"
+                    
+                    result += f"{emoji} **{name} ({symbol})**: ${price:,.4f} ({change_24h:+.2f}%) | MCap: {mcap_formatted}\n"
+                    
+                except (TypeError, KeyError, ValueError) as e:
+                    logger.warning(f"Skipping invalid coin data: {e}")
+                    continue
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Market overview error: {e}")
+            return "⚠️ Market overview temporarily unavailable"
+
+    async def _get_coin_data(self, query: str) -> str:
+        if not query or not query.strip():
+            return "❌ Please provide a cryptocurrency symbol or name"
         
-        return result
-    
         coin_id = self._symbol_map.get(query.lower(), query.lower())
-        coin_id = self.symbol_map.get(query.lower(), query.lower())
-        
         params = {
             "ids": coin_id,
             "vs_currencies": "usd",
@@ -80,34 +122,76 @@ class CoinGeckoTool(BaseWeb3Tool):
             "include_24hr_vol": "true",
             "include_market_cap": "true"
         }
-        data = await self.make_request(f"{self._base_url}/simple/price", params)
-        data = await self.make_request(f"{self.base_url}/simple/price", params)
-        
-        if coin_id not in data:
-            return f"No data found for {query}"
-        
-        coin_data = data[coin_id]
-        price = coin_data.get("usd", 0)
-        change = coin_data.get("usd_24h_change", 0)
-        volume = coin_data.get("usd_24h_vol", 0)
-        mcap = coin_data.get("usd_market_cap", 0)
-        
-        emoji = "📈" if change >= 0 else "📉"
-        
-        result = f"💰 **{query.upper()} Market Data:**\n\n"
-        result += f"{emoji} **Price**: ${price:,.4f}\n"
-        result += f"📊 **24h Change**: {change:+.2f}%\n"
-        result += f"📈 **24h Volume**: ${volume:,.0f}\n"
-        result += f"🏦 **Market Cap**: ${mcap:,.0f}\n"
         
-        return result
+        try:
+            data = await self.make_request(f"{self._base_url}/simple/price", params=params)
+            
+            if not data or coin_id not in data:
+                # Try alternative search if direct lookup fails
+                search_data = await self._search_coin(query)
+                if search_data:
+                    return search_data
+                return f"❌ No data found for '{query}'. Try using full name or common symbols like BTC, ETH, SOL"
+            
+            coin_data = data[coin_id]
+            
+            # Validate required fields
+            if "usd" not in coin_data:
+                return f"❌ Price data unavailable for {query.upper()}"
+            
+            price = coin_data.get("usd", 0)
+            change_24h = coin_data.get("usd_24h_change", 0)
+            volume_24h = coin_data.get("usd_24h_vol", 0)
+            market_cap = coin_data.get("usd_market_cap", 0)
+            
+            # Handle edge cases
+            if price <= 0:
+                return f"⚠️ {query.upper()} price data appears invalid"
+            
+            emoji = "📈" if change_24h >= 0 else "📉"
+            
+            result = f"💰 **{query.upper()} Market Data:**\n\n"
+            result += f"{emoji} **Price**: ${price:,.4f}\n"
+            result += f"📊 **24h Change**: {change_24h:+.2f}%\n"
+            
+            if volume_24h > 0:
+                result += f"📈 **24h Volume**: ${volume_24h:,.0f}\n"
+            else:
+                result += f"📈 **24h Volume**: Data unavailable\n"
+            
+            if market_cap > 0:
+                result += f"🏦 **Market Cap**: ${market_cap:,.0f}\n"
+            else:
+                result += f"🏦 **Market Cap**: Data unavailable\n"
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Error fetching coin data for {query}: {e}")
+            return f"⚠️ Unable to fetch data for {query.upper()}. Please try again later."
     
+    async def _search_coin(self, query: str) -> Optional[str]:
+        """Fallback search when direct ID lookup fails"""
+        try:
+            search_params = {"query": query}
+            search_data = await self.make_request(f"{self._base_url}/search", params=search_params)
+            
+            coins = search_data.get("coins", [])
+            if coins:
+                coin = coins[0]  # Take first match
+                coin_id = coin.get("id")
+                if coin_id:
+                    return await self._get_coin_data(coin_id)
+            
+            return None
+        except Exception:
+            return None
+
+    async def _get_price_history(self, symbol: str, days: int) -> str:
         coin_id = self._symbol_map.get(symbol.lower(), symbol.lower())
-        
         params = {"vs_currency": "usd", "days": days}
-        data = await self.make_request(f"{self._base_url}/coins/{coin_id}/market_chart", params)
-        data = await self.make_request(f"{self.base_url}/coins/{coin_id}/market_chart", params)
-        
+        data = await self.make_request(f"{self._base_url}/coins/{coin_id}/market_chart", params=params)
+        # you can format this as you like; here’s a simple JSON dump
         return {
             "symbol": symbol.upper(),
             "prices": data.get("prices", []),

src/tools/defillama_tool.py

@@ -1,6 +1,9 @@
 from typing import Dict, Any, Optional
 from pydantic import BaseModel, PrivateAttr
 from src.tools.base_tool import BaseWeb3Tool, Web3ToolInput
+from src.utils.logger import get_logger
+
+logger = get_logger(__name__)
 
 class DeFiLlamaTool(BaseWeb3Tool):
     name: str = "defillama_data"
@@ -28,28 +31,63 @@ class DeFiLlamaTool(BaseWeb3Tool):
                 return await self._get_top_protocols()
                 
         except Exception as e:
-            return f"DeFiLlama error: {str(e)}"
+            logger.error(f"DeFiLlama error: {e}")
+            return f"⚠️ DeFiLlama service temporarily unavailable: {str(e)}"
     
     async def _get_top_protocols(self) -> str:
-        data = await self.make_request(f"{self.base_url}/protocols")
-        
-        if not data:
-            return "No DeFi protocol data available"
-        
-        top_protocols = sorted(data, key=lambda x: x.get("tvl", 0), reverse=True)[:10]
-        
-        result = "🏦 **Top DeFi Protocols by TVL:**\n\n"
-        
-        for i, protocol in enumerate(top_protocols, 1):
-            name = protocol.get("name", "Unknown")
-            tvl = protocol.get("tvl", 0)
-            change = protocol.get("change_1d", 0)
-            chain = protocol.get("chain", "Multi-chain")
+        try:
+            data = await self.make_request(f"{self._base_url}/protocols")
             
-            emoji = "📈" if change >= 0 else "📉"
-            result += f"{i}. **{name}** ({chain}): ${tvl/1e9:.2f}B TVL {emoji} ({change:+.2f}%)\n"
-        
-        return result
+            if not data or not isinstance(data, list):
+                return "⚠️ DeFi protocol data temporarily unavailable"
+            
+            if len(data) == 0:
+                return "❌ No DeFi protocols found"
+            
+            # Filter and validate protocols
+            valid_protocols = []
+            for protocol in data:
+                try:
+                    tvl = protocol.get("tvl", 0)
+                    if tvl is not None and tvl > 0:
+                        valid_protocols.append(protocol)
+                except (TypeError, ValueError):
+                    continue
+            
+            if not valid_protocols:
+                return "⚠️ No valid protocol data available"
+            
+            # Sort by TVL and take top 10
+            top_protocols = sorted(valid_protocols, key=lambda x: x.get("tvl", 0), reverse=True)[:10]
+            
+            result = "🏦 **Top DeFi Protocols by TVL:**\n\n"
+            
+            for i, protocol in enumerate(top_protocols, 1):
+                try:
+                    name = protocol.get("name", "Unknown")
+                    tvl = protocol.get("tvl", 0)
+                    change = protocol.get("change_1d", 0)
+                    chain = protocol.get("chain", "Multi-chain")
+                    
+                    # Handle edge cases
+                    if tvl <= 0:
+                        continue
+                    
+                    emoji = "📈" if change >= 0 else "📉"
+                    tvl_formatted = f"${tvl/1e9:.2f}B" if tvl >= 1e9 else f"${tvl/1e6:.1f}M"
+                    change_formatted = f"({change:+.2f}%)" if change is not None else "(N/A)"
+                    
+                    result += f"{i}. **{name}** ({chain}): {tvl_formatted} TVL {emoji} {change_formatted}\n"
+                    
+                except (TypeError, KeyError, ValueError) as e:
+                    logger.warning(f"Skipping invalid protocol data: {e}")
+                    continue
+            
+            return result if len(result.split('\n')) > 3 else "⚠️ Unable to format protocol data properly"
+            
+        except Exception as e:
+            logger.error(f"Top protocols error: {e}")
+            return "⚠️ DeFi protocol data temporarily unavailable"
     
     async def _get_tvl_overview(self) -> str:
         try:

src/tools/etherscan_tool.py

@@ -2,6 +2,9 @@ from typing import Dict, Any, Optional
 from pydantic import BaseModel, PrivateAttr
 from src.tools.base_tool import BaseWeb3Tool, Web3ToolInput
 from src.utils.config import config
+from src.utils.logger import get_logger
+
+logger = get_logger(__name__)
 
 class EtherscanTool(BaseWeb3Tool):
     name: str = "etherscan_data"
@@ -16,10 +19,14 @@ class EtherscanTool(BaseWeb3Tool):
     def __init__(self):
         super().__init__()
         self._api_key = config.ETHERSCAN_API_KEY
+        self.enabled = bool(self._api_key)
+        
+        if not self.enabled:
+            logger.warning("Etherscan API key not configured - limited functionality")
     
     async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None) -> str:
-        if not self.api_key:
-            return "❌ Etherscan API key not configured"
+        if not self.enabled:
+            return "⚠️ **Etherscan Service Limited**\n\nEtherscan functionality requires an API key.\nGet yours free at: https://etherscan.io/apis\n\nSet environment variable: `ETHERSCAN_API_KEY=your_key`"
         
         try:
             filters = filters or {}
@@ -36,46 +43,76 @@ class EtherscanTool(BaseWeb3Tool):
                 return await self._get_gas_prices()
                 
         except Exception as e:
-            return f"Etherscan error: {str(e)}"
+            logger.error(f"Etherscan error: {e}")
+            return f"⚠️ Etherscan service temporarily unavailable"
     
     def _is_address(self, query: str) -> bool:
-        return len(query) == 42 and query.startswith("0x")
+        return (
+            len(query) == 42 
+            and query.startswith("0x") 
+            and all(c in "0123456789abcdefABCDEF" for c in query[2:])
+        )
     
     def _is_tx_hash(self, query: str) -> bool:
-        return len(query) == 66 and query.startswith("0x")
+        return (
+            len(query) == 66 
+            and query.startswith("0x")
+            and all(c in "0123456789abcdefABCDEF" for c in query[2:])
+        )
     
     async def _get_gas_prices(self) -> str:
-        params = {
-            "module": "gastracker",
-            "action": "gasoracle",
-            "apikey": self.api_key
-        }
-        
-        data = await self.make_request(self.base_url, params)
-        
-        if data.get("status") != "1":
-            return "Gas price data unavailable"
-        
-        result_data = data.get("result", {})
-        safe_gas = result_data.get("SafeGasPrice", "N/A")
-        standard_gas = result_data.get("StandardGasPrice", "N/A")
-        fast_gas = result_data.get("FastGasPrice", "N/A")
-        
-        result = "⛽ **Ethereum Gas Prices:**\n\n"
-        result += f"🐌 **Safe**: {safe_gas} gwei\n"
-        result += f"⚡ **Standard**: {standard_gas} gwei\n"
-        result += f"🚀 **Fast**: {fast_gas} gwei\n"
-        
-        return result
+        try:
+            params = {
+                "module": "gastracker",
+                "action": "gasoracle",
+                "apikey": self._api_key
+            }
+            
+            data = await self.make_request(self._base_url, params)
+            
+            if not data or data.get("status") != "1":
+                error_msg = data.get("message", "Unknown error") if data else "No response"
+                logger.warning(f"Etherscan gas price error: {error_msg}")
+                return "⚠️ Gas price data temporarily unavailable"
+            
+            result_data = data.get("result", {})
+            if not result_data:
+                return "❌ No gas price data in response"
+            
+            safe_gas = result_data.get("SafeGasPrice", "N/A")
+            standard_gas = result_data.get("StandardGasPrice", "N/A")
+            fast_gas = result_data.get("FastGasPrice", "N/A")
+            
+            # Validate gas prices are numeric
+            try:
+                if safe_gas != "N/A":
+                    float(safe_gas)
+                if standard_gas != "N/A":
+                    float(standard_gas)
+                if fast_gas != "N/A":
+                    float(fast_gas)
+            except (ValueError, TypeError):
+                return "⚠️ Invalid gas price data received"
+            
+            result = "⛽ **Ethereum Gas Prices:**\n\n"
+            result += f"🐌 **Safe**: {safe_gas} gwei\n"
+            result += f"⚡ **Standard**: {standard_gas} gwei\n"
+            result += f"🚀 **Fast**: {fast_gas} gwei\n"
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Gas prices error: {e}")
+            return "⚠️ Gas price service temporarily unavailable"
     
     async def _get_eth_stats(self) -> str:
         params = {
             "module": "stats",
             "action": "ethsupply",
-            "apikey": self.api_key
+            "apikey": self._api_key
         }
         
-        data = await self.make_request(self.base_url, params)
+        data = await self.make_request(self._base_url, params)
         
         if data.get("status") != "1":
             return "Ethereum stats unavailable"
@@ -90,14 +127,17 @@ class EtherscanTool(BaseWeb3Tool):
     async def _get_address_info(self, address: str) -> str:
         params = {
             "module": "account",
-            "action": "balance", 
+            "action": "txlist",
             "address": address,
-            "tag": "latest",
-            "apikey": self.api_key
+            "startblock": "0",
+            "endblock": "99999999",
+            "page": "1",
+            "offset": "10",
+            "sort": "desc",
+            "apikey": self._api_key
         }
         
-        data = await self.make_request(self.base_url, params)
-        
+        data = await self.make_request(self._base_url, params)
         if data.get("status") != "1":
             return f"Address information unavailable for {address}"
         
@@ -115,10 +155,10 @@ class EtherscanTool(BaseWeb3Tool):
             "module": "proxy",
             "action": "eth_getTransactionByHash",
             "txhash": tx_hash,
-            "apikey": self.api_key
+            "apikey": self._api_key
         }
         
-        data = await self.make_request(self.base_url, params)
+        data = await self.make_request(self._base_url, params)
         
         if not data.get("result"):
             return f"Transaction not found: {tx_hash}"

src/{cache_manager.py → utils/cache_manager.py}

@@ -1,35 +1,49 @@
 import time
 from typing import Any, Optional, Dict
-from src.config import config
+from src.utils.config import config
+from src.utils.logger import get_logger
+
+logger = get_logger(__name__)
 
 class CacheManager:
     def __init__(self, default_ttl: Optional[int] = None):
         self.cache: Dict[str, Dict[str, Any]] = {}
         self.default_ttl = default_ttl or config.CACHE_TTL
+        self.hits = 0
+        self.misses = 0
     
     def get(self, key: str) -> Optional[Any]:
         if key not in self.cache:
+            self.misses += 1
             return None
         
         entry = self.cache[key]
         if time.time() > entry["expires_at"]:
             del self.cache[key]
+            self.misses += 1
             return None
         
+        self.hits += 1
         return entry["data"]
     
     def set(self, key: str, data: Any, ttl: Optional[int] = None) -> None:
-        expires_at = time.time() + (ttl or self.default_ttl)
-        self.cache[key] = {
-            "data": data,
-            "expires_at": expires_at
-        }
+        try:
+            expires_at = time.time() + (ttl or self.default_ttl)
+            self.cache[key] = {
+                "data": data,
+                "expires_at": expires_at,
+                "created_at": time.time()
+            }
+        except Exception as e:
+            logger.warning(f"Cache set failed for {key}: {e}")
     
     def delete(self, key: str) -> bool:
         return self.cache.pop(key, None) is not None
     
     def clear(self) -> None:
         self.cache.clear()
+        self.hits = 0
+        self.misses = 0
     
     def cleanup_expired(self) -> int:
         current_time = time.time()
@@ -45,5 +59,17 @@ class CacheManager:
     
     def size(self) -> int:
         return len(self.cache)
+    
+    def stats(self) -> Dict[str, Any]:
+        total_requests = self.hits + self.misses
+        hit_rate = (self.hits / total_requests * 100) if total_requests > 0 else 0
+        
+        return {
+            "size": self.size(),
+            "hits": self.hits,
+            "misses": self.misses,
+            "hit_rate": f"{hit_rate:.1f}%",
+            "expired_cleaned": self.cleanup_expired()
+        }
 
 cache_manager = CacheManager()

src/utils/config.py

@@ -1 +1,30 @@
-from src.config import config
+import os
+from dataclasses import dataclass
+from typing import Optional
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+@dataclass
+class Config:
+    GEMINI_API_KEY: str = os.getenv("GEMINI_API_KEY", "")
+    COINGECKO_API_KEY: Optional[str] = os.getenv("COINGECKO_API_KEY")
+    CRYPTOCOMPARE_API_KEY: Optional[str] = os.getenv("CRYPTOCOMPARE_API_KEY")
+    ETHERSCAN_API_KEY: str = os.getenv("ETHERSCAN_API_KEY", "")
+    
+    COINGECKO_BASE_URL: str = "https://api.coingecko.com/api/v3"
+    CRYPTOCOMPARE_BASE_URL: str = "https://min-api.cryptocompare.com/data"
+    
+    CACHE_TTL: int = 300
+    RATE_LIMIT_DELAY: float = 2.0
+    MAX_RETRIES: int = 3
+    REQUEST_TIMEOUT: int = 30
+    
+    UI_TITLE: str = "Web3 Research Co-Pilot"
+    UI_DESCRIPTION: str = "AI-powered crypto research assistant"
+    
+    AIRAA_WEBHOOK_URL: Optional[str] = os.getenv("AIRAA_WEBHOOK_URL")
+    AIRAA_API_KEY: Optional[str] = os.getenv("AIRAA_API_KEY")
+
+config = Config()

src/visualizations.py

@@ -1,62 +0,0 @@
-import plotly.graph_objects as go
-from datetime import datetime
-from typing import Dict, Any
-
-def create_price_chart(data: Dict[str, Any], symbol: str) -> go.Figure:
-    try:
-        if not data or "prices" not in data:
-            return _empty_chart(f"No price data for {symbol}")
-        
-        prices = data["prices"]
-        timestamps = [datetime.fromtimestamp(p[0]/1000) for p in prices]
-        values = [p[1] for p in prices]
-        
-        fig = go.Figure()
-        fig.add_trace(go.Scatter(
-            x=timestamps, y=values, mode='lines',
-            name=f'{symbol.upper()} Price',
-            line=dict(color='#00D4AA', width=2)
-        ))
-        
-        fig.update_layout(
-            title=f'{symbol.upper()} Price History',
-            xaxis_title='Date', yaxis_title='Price (USD)',
-            template='plotly_dark', height=400
-        )
-        
-        return fig
-    except Exception:
-        return _empty_chart(f"Chart error for {symbol}")
-
-def create_market_overview(data: Dict[str, Any]) -> go.Figure:
-    try:
-        if not data:
-            return _empty_chart("No market data available")
-        
-        fig = go.Figure()
-        fig.add_annotation(
-            text="Market Overview\n" + str(data)[:200] + "...",
-            x=0.5, y=0.5, font=dict(size=12, color="white"),
-            showarrow=False, align="left"
-        )
-        
-        fig.update_layout(
-            title="Market Overview", template='plotly_dark', height=400,
-            xaxis=dict(visible=False), yaxis=dict(visible=False)
-        )
-        
-        return fig
-    except Exception:
-        return _empty_chart("Market overview error")
-
-def _empty_chart(message: str) -> go.Figure:
-    fig = go.Figure()
-    fig.add_annotation(
-        text=message, x=0.5, y=0.5,
-        font=dict(size=16, color="white"), showarrow=False
-    )
-    fig.update_layout(
-        template='plotly_dark', height=400,
-        xaxis=dict(visible=False), yaxis=dict(visible=False)
-    )
-    return fig

test_app.py

@@ -1,108 +0,0 @@
-#!/usr/bin/env python3
-
-import sys
-import os
-
-sys.path.insert(0, os.path.dirname(__file__))
-
-def test_imports():
-    try:
-        print("Testing imports...")
-        
-        # Test basic Python modules
-        import json
-        import asyncio
-        from datetime import datetime
-        from typing import List, Tuple
-        print("✅ Basic Python modules imported successfully")
-        
-        # Test installed packages
-        import gradio as gr
-        print("✅ Gradio imported successfully")
-        
-        import aiohttp
-        print("✅ aiohttp imported successfully")
-        
-        import plotly
-        print("✅ Plotly imported successfully")
-        
-        import pandas
-        print("✅ Pandas imported successfully")
-        
-        import pydantic
-        print("✅ Pydantic imported successfully")
-        
-        # Test LangChain
-        import langchain
-        from langchain.agents import AgentExecutor
-        from langchain_google_genai import ChatGoogleGenerativeAI
-        print("✅ LangChain modules imported successfully")
-        
-        # Test our modules
-        from src.utils.config import config
-        from src.utils.logger import get_logger
-        print("✅ Config and logger imported successfully")
-        
-        from src.tools.base_tool import BaseWeb3Tool
-        from src.tools.coingecko_tool import CoinGeckoTool
-        from src.tools.defillama_tool import DeFiLlamaTool
-        from src.tools.etherscan_tool import EtherscanTool
-        print("✅ Tools imported successfully")
-        
-        from src.agent.research_agent import Web3ResearchAgent
-        from src.agent.query_planner import QueryPlanner
-        print("✅ Agent modules imported successfully")
-        
-        from src.api.airaa_integration import AIRAAIntegration
-        print("✅ AIRAA integration imported successfully")
-        
-        from src.visualizations import create_price_chart, create_market_overview
-        print("✅ Visualizations imported successfully")
-        
-        # Test app import
-        from app import Web3CoPilotApp
-        print("✅ Main app imported successfully")
-        
-        print("\n🎉 All imports successful! The application is ready to run.")
-        return True
-        
-    except ImportError as e:
-        print(f"❌ Import error: {e}")
-        return False
-    except Exception as e:
-        print(f"❌ Unexpected error: {e}")
-        return False
-
-def test_app_initialization():
-    try:
-        print("\nTesting app initialization...")
-        # This will test if we can create the app instance
-        # but won't actually run it
-        os.environ.setdefault('GEMINI_API_KEY', 'test_key_for_import_test')
-        
-        from app import Web3CoPilotApp
-        print("✅ App class imported successfully")
-        
-        # Test if we can create the interface (but don't launch)
-        app = Web3CoPilotApp()
-        interface = app.create_interface()
-        print("✅ App interface created successfully")
-        
-        print("\n🚀 Application is fully functional and ready to launch!")
-        return True
-        
-    except Exception as e:
-        print(f"❌ App initialization error: {e}")
-        return False
-
-if __name__ == "__main__":
-    print("=" * 60)
-    print("Web3 Research Co-Pilot - Application Test")
-    print("=" * 60)
-    
-    success = test_imports()
-    if success:
-        test_app_initialization()
-    
-    print("=" * 60)
-    print("Test complete!")