feat: added api tools

.env.example

@@ -1,5 +1,5 @@
 # Google Gemini API Key (Required)
-GEMINI_API_KEY=your_gemini_api_key_here
+GEMINI_API_KEY=AIzaSyCgOdLBoDEeG7vONzCZgm1l9dJFyIYrZOw
 
 # CoinGecko API Key (Optional - for higher rate limits)
 COINGECKO_API_KEY=your_coingecko_api_key_here

.gitignore

@@ -0,0 +1,29 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.venv/
+pip-log.txt
+pip-delete-this-directory.txt
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+.git
+.mypy_cache
+.pytest_cache
+.hypothesis
+
+.DS_Store
+.env
+.flaskenv
+*.env
+
+gradio_queue.db

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+ENV PYTHONPATH=/app
+ENV GRADIO_SERVER_NAME=0.0.0.0
+ENV GRADIO_SERVER_PORT=7860
+
+CMD ["python", "app.py"]

README.md

@@ -0,0 +1,66 @@
+# Web3 Research Co-Pilot
+
+AI-powered cryptocurrency research assistant built with LangChain and Gradio.
+
+## Features
+
+- **Real-time Market Analysis**: CoinGecko, DeFiLlama, Etherscan integration
+- **AI Research Agent**: Powered by Google Gemini
+- **Interactive Interface**: Modern Gradio UI
+- **Data Visualization**: Price charts and market overviews
+- **AIRAA Integration**: Webhook support for external platforms
+
+## Quick Start
+
+1. **Clone and Setup**
+```bash
+git clone <repository-url>
+cd web3-research-agent
+pip install -r requirements.txt
+```
+
+2. **Environment Configuration**
+```bash
+cp .env.example .env
+# Edit .env with your API keys
+```
+
+3. **Run Application**
+```bash
+python app.py
+```
+
+## Required API Keys
+
+- `GEMINI_API_KEY`: Google Gemini AI (required)
+- `ETHERSCAN_API_KEY`: Ethereum blockchain data
+- `COINGECKO_API_KEY`: Cryptocurrency market data (optional)
+- `AIRAA_WEBHOOK_URL`: External integration (optional)
+
+## Deployment
+
+### Docker
+```bash
+docker build -t web3-research-agent .
+docker run -p 7860:7860 --env-file .env web3-research-agent
+```
+
+### Hugging Face Spaces
+Upload repository to HF Spaces with environment variables configured.
+
+## Architecture
+
+- **Agent**: LangChain-based research agent with memory
+- **Tools**: Modular API integrations (CoinGecko, DeFiLlama, Etherscan)
+- **UI**: Gradio interface with chat and visualization
+- **Cache**: Optimized caching for API responses
+- **Integration**: AIRAA webhook support
+
+## Usage Examples
+
+- "Bitcoin price analysis and market sentiment"
+- "Top DeFi protocols by TVL"
+- "Ethereum gas prices and network stats" 
+- "Compare BTC vs ETH performance"
+
+Built with ❤️ for Web3 research

app.py

@@ -1,312 +1,151 @@
 import gradio as gr
-import os
-import json
-from src.enhanced_agent import EnhancedResearchAgent
-from src.portfolio_analyzer import portfolio_analyzer
-from src.visualizations import create_price_chart, create_market_overview, create_comparison_chart
-from src.cache_manager import cache_manager
 import asyncio
+import json
+from datetime import datetime
+from typing import List, Tuple
 
-research_agent = EnhancedResearchAgent()
-
-async def process_research_query(query, history):
-    try:
-        if not query.strip():
-            return history + [["Please enter a research query.", ""]]
-        
-        response = await research_agent.research_with_context(query)
-        return history + [[query, response]]
-    except Exception as e:
-        error_msg = f"Enhanced research failed: {str(e)}"
-        return history + [[query, error_msg]]
-
-def research_query_sync(query, history):
-    return asyncio.run(process_research_query(query, history))
-
-async def get_market_data():
-    try:
-        data = await research_agent.get_comprehensive_market_data()
-        chart = create_market_overview(data)
-        return chart
-    except Exception as e:
-        return f"Enhanced market data unavailable: {str(e)}"
-
-def get_market_data_sync():
-    return asyncio.run(get_market_data())
-
-async def get_price_chart(symbol):
-    try:
-        if not symbol.strip():
-            return "Please enter a cryptocurrency symbol"
-        
-        data = await research_agent.get_price_history(symbol)
-        chart = create_price_chart(data, symbol)
-        return chart
-    except Exception as e:
-        return f"Chart generation failed: {str(e)}"
-
-def get_price_chart_sync(symbol):
-    return asyncio.run(get_price_chart(symbol))
+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
 
-async def analyze_portfolio_async(portfolio_text):
-    try:
-        if not portfolio_text.strip():
-            return "Please enter your portfolio holdings in JSON format"
-        
-        holdings = json.loads(portfolio_text)
-        analysis = await portfolio_analyzer.analyze_portfolio(holdings)
-        
-        result = f"📊 PORTFOLIO ANALYSIS\n\n"
-        result += f"💰 Total Value: ${analysis['total_value']:,.2f}\n"
-        result += f"📈 24h Change: ${analysis['change_24h']:+,.2f} ({analysis['change_24h_percentage']:+.2f}%)\n\n"
-        
-        result += "🏦 ASSET ALLOCATION:\n"
-        for asset in analysis['asset_allocation'][:10]:
-            result += f"• {asset['name']} ({asset['symbol']}): {asset['percentage']:.1f}% (${asset['value']:,.2f})\n"
-        
-        result += f"\n⚠️ RISK ASSESSMENT:\n"
-        result += f"Overall Risk: {analysis['risk_metrics']['overall_risk']}\n"
-        result += f"Diversification Score: {analysis['risk_metrics']['diversification_score']}/10\n"
-        result += f"Largest Position: {analysis['risk_metrics']['largest_holding_percentage']:.1f}%\n\n"
-        
-        result += "💡 RECOMMENDATIONS:\n"
-        for i, rec in enumerate(analysis['recommendations'], 1):
-            result += f"{i}. {rec}\n"
-        
-        return result
-        
-    except json.JSONDecodeError:
-        return "❌ Invalid JSON format. Please use format: [{'symbol': 'BTC', 'amount': 1.0}, {'symbol': 'ETH', 'amount': 10.0}]"
-    except Exception as e:
-        return f"❌ Portfolio analysis failed: {str(e)}"
+logger = get_logger(__name__)
 
-async def get_defi_analysis_async():
-    try:
-        data = await research_agent.get_defi_analysis()
-        
-        result = "🏦 DeFi ECOSYSTEM ANALYSIS\n\n"
-        
-        if "top_protocols" in data:
-            result += "📊 TOP PROTOCOLS BY TVL:\n"
-            for i, protocol in enumerate(data["top_protocols"][:10], 1):
-                name = protocol.get("name", "Unknown")
-                tvl = protocol.get("tvl", 0)
-                chain = protocol.get("chain", "Unknown")
-                change = protocol.get("change_1d", 0)
-                result += f"{i:2d}. {name} ({chain}): ${tvl/1e9:.2f}B TVL ({change:+.2f}%)\n"
-        
-        if "top_yields" in data:
-            result += "\n💰 HIGH YIELD OPPORTUNITIES:\n"
-            for i, pool in enumerate(data["top_yields"][:5], 1):
-                symbol = pool.get("symbol", "Unknown")
-                apy = pool.get("apy", 0)
-                tvl = pool.get("tvlUsd", 0)
-                result += f"{i}. {symbol}: {apy:.2f}% APY (${tvl/1e6:.1f}M TVL)\n"
-        
-        return result
+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
         
-    except Exception as e:
-        return f"❌ DeFi analysis failed: {str(e)}"
-
-def clear_cache():
-    cache_manager.clear()
-    return "Cache cleared successfully"
-
-def analyze_portfolio_sync(portfolio_text):
-    return asyncio.run(analyze_portfolio_async(portfolio_text))
-
-def get_defi_analysis_sync():
-    return asyncio.run(get_defi_analysis_async())
-
-with gr.Blocks(
-    title="Web3 Research Co-Pilot",
-    theme=gr.themes.Soft(primary_hue="blue", secondary_hue="gray"),
-    css="""
-    .container { max-width: 1200px; margin: 0 auto; }
-    .header { text-align: center; padding: 20px; }
-    .chat-container { min-height: 400px; }
-    .chart-container { min-height: 500px; }
-    """
-) as app:
+        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, ""
     
-    gr.Markdown("# 🚀 Web3 Research Co-Pilot", elem_classes=["header"])
-    gr.Markdown("*AI-powered cryptocurrency research with real-time data integration*", elem_classes=["header"])
+    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)}"
     
-    with gr.Tabs():
-        
-        with gr.Tab("🤖 Research Chat"):
+    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=3):
-                    chatbot = gr.Chatbot(
-                        value=[],
-                        height=400,
-                        elem_classes=["chat-container"],
-                        show_label=False
-                    )
+                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, prices, trends, analysis...",
-                            scale=4,
-                            show_label=False
+                            placeholder="Ask about crypto markets, DeFi protocols, or on-chain data...",
+                            label="Research Query", lines=2
                         )
-                        submit_btn = gr.Button("Research", variant="primary")
+                        submit_btn = gr.Button("🔍 Research", variant="primary")
                     
-                    gr.Examples(
-                        examples=[
-                            "What's the current Bitcoin price and trend?",
-                            "Compare Ethereum vs Solana DeFi ecosystems",
-                            "Analyze top DeFi protocols and TVL trends",
-                            "What are the trending coins and latest crypto news?",
-                            "Show me high-yield DeFi opportunities with risk analysis"
-                        ],
-                        inputs=query_input
-                    )
+                    clear_btn = gr.Button("🗑️ Clear", variant="secondary")
                 
                 with gr.Column(scale=1):
-                    gr.Markdown("### 📊 Quick Actions")
-                    market_btn = gr.Button("Market Overview", size="sm")
-                    market_output = gr.HTML()
+                    gr.Markdown("### 💡 Example Queries")
                     
-                    clear_btn = gr.Button("Clear Cache", size="sm", variant="secondary")
-                    clear_output = gr.Textbox(show_label=False, interactive=False)
-        
-        with gr.Tab("📈 Price Charts"):
-            with gr.Row():
-                symbol_input = gr.Textbox(
-                    label="Cryptocurrency Symbol",
-                    placeholder="BTC, ETH, SOL, etc.",
-                    value="BTC"
-                )
-                chart_btn = gr.Button("Generate Chart", variant="primary")
-            
-            chart_output = gr.HTML(elem_classes=["chart-container"])
+                    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")
             
-            gr.Examples(
-                examples=["BTC", "ETH", "SOL", "ADA", "DOT"],
-                inputs=symbol_input
+            submit_btn.click(
+                self.process_query,
+                inputs=[query_input, chatbot],
+                outputs=[chatbot, query_input]
             )
-        
-        with gr.Tab("💼 Portfolio Analysis"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    portfolio_input = gr.Textbox(
-                        label="Portfolio Holdings (JSON Format)",
-                        placeholder='[{"symbol": "BTC", "amount": 1.0}, {"symbol": "ETH", "amount": 10.0}, {"symbol": "SOL", "amount": 50.0}]',
-                        lines=5,
-                        info="Enter your crypto holdings in JSON format with symbol and amount"
-                    )
-                    portfolio_btn = gr.Button("Analyze Portfolio", variant="primary")
-                
-                with gr.Column(scale=2):
-                    portfolio_output = gr.Textbox(
-                        label="Portfolio Analysis Results",
-                        lines=20,
-                        show_copy_button=True,
-                        interactive=False
-                    )
             
-            gr.Examples(
-                examples=[
-                    '[{"symbol": "BTC", "amount": 0.5}, {"symbol": "ETH", "amount": 5.0}]',
-                    '[{"symbol": "BTC", "amount": 1.0}, {"symbol": "ETH", "amount": 10.0}, {"symbol": "SOL", "amount": 100.0}]'
-                ],
-                inputs=portfolio_input
-            )
-        
-        with gr.Tab("🏦 DeFi Analytics"):
-            defi_btn = gr.Button("Get DeFi Ecosystem Analysis", variant="primary", size="lg")
-            defi_output = gr.Textbox(
-                label="DeFi Analysis Results",
-                lines=25,
-                show_copy_button=True,
-                interactive=False,
-                info="Comprehensive DeFi protocol analysis with TVL data and yield opportunities"
+            query_input.submit(
+                self.process_query,
+                inputs=[query_input, chatbot],
+                outputs=[chatbot, query_input]
             )
-        
-        with gr.Tab("ℹ️ About"):
-            gr.Markdown("""
-            ## 🚀 Enhanced Features
-            - **Multi-API Integration**: CoinGecko, CryptoCompare, and DeFiLlama data sources
-            - **AI-Powered Analysis**: Google Gemini 2.5 Flash with contextual market intelligence
-            - **DeFi Analytics**: Protocol TVL analysis, yield farming opportunities, and ecosystem insights
-            - **Portfolio Analysis**: Risk assessment, diversification scoring, and personalized recommendations
-            - **News Integration**: Real-time crypto news aggregation and sentiment analysis
-            - **Interactive Charts**: Advanced price visualizations with technical indicators
-            - **Smart Caching**: Optimized performance with intelligent data caching (TTL-based)
-            - **Rate Limiting**: Respectful API usage with automatic throttling
             
-            ## 🎯 Core Capabilities
-            1. **Enhanced Research Chat**: Context-aware conversations with real-time market data integration
-            2. **Advanced Price Charts**: Interactive visualizations with 30-day historical data
-            3. **Portfolio Optimization**: Comprehensive portfolio analysis with risk metrics and recommendations
-            4. **DeFi Intelligence**: Protocol rankings, TVL trends, and high-yield opportunity identification
-            5. **Market Intelligence**: Global market metrics, trending assets, and breaking news analysis
+            clear_btn.click(lambda: ([], ""), outputs=[chatbot, query_input])
             
-            ## 💡 Query Examples
-            - "Analyze Bitcoin vs Ethereum DeFi ecosystem performance"
-            - "What are the top DeFi protocols by TVL with lowest risk?"
-            - "Show me high-yield farming opportunities under 15% volatility"
-            - "Compare my portfolio risk to market benchmarks"
-            - "Latest crypto news impact on altcoin market sentiment"
-            - "Which Layer 1 protocols have strongest DeFi adoption?"
+            chart_btn.click(
+                self.get_chart_data,
+                inputs=symbol_input,
+                outputs=chart_output
+            )
             
-            ## 🔧 Technical Architecture
-            - **Async Processing**: Non-blocking operations for optimal performance
-            - **Error Handling**: Comprehensive exception management with graceful degradation
-            - **Symbol Mapping**: Intelligent cryptocurrency identifier resolution
-            - **Data Validation**: Input sanitization and response formatting
-            """)
-    
-    submit_btn.click(
-        research_query_sync,
-        inputs=[query_input, chatbot],
-        outputs=chatbot
-    ).then(lambda: "", outputs=query_input)
-    
-    query_input.submit(
-        research_query_sync,
-        inputs=[query_input, chatbot],
-        outputs=chatbot
-    ).then(lambda: "", outputs=query_input)
-    
-    chart_btn.click(
-        get_price_chart_sync,
-        inputs=symbol_input,
-        outputs=chart_output
-    )
-    
-    symbol_input.submit(
-        get_price_chart_sync,
-        inputs=symbol_input,
-        outputs=chart_output
-    )
-    
-    market_btn.click(
-        get_market_data_sync,
-        outputs=market_output
-    )
-    
-    clear_btn.click(
-        clear_cache,
-        outputs=clear_output
-    )
-    
-    portfolio_btn.click(
-        analyze_portfolio_sync,
-        inputs=portfolio_input,
-        outputs=portfolio_output
-    )
-    
-    defi_btn.click(
-        get_defi_analysis_sync,
-        outputs=defi_output
-    )
+            market_btn.click(
+                self.get_market_overview,
+                outputs=chart_output
+            )
+        
+        return demo
 
 if __name__ == "__main__":
-    app.launch(
+    app = Web3CoPilotApp()
+    interface = app.create_interface()
+    interface.launch(
         server_name="0.0.0.0",
-        server_port=5000,
-        share=False,
-        show_error=True
+        server_port=7860,
+        share=False
     )

minimal_test.py

@@ -0,0 +1,36 @@
+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,7 +1,14 @@
-aiohttp==3.10.11
-gradio==5.8.0
-google-generativeai==0.8.3
-plotly==5.24.1
-pandas==2.2.3
-python-dotenv==1.0.1
-asyncio-throttle==1.0.2
+langchain
+langchain-google-genai
+langchain-community
+gradio
+aiohttp
+tenacity
+plotly
+pandas
+numpy
+pydantic
+python-dotenv
+diskcache
+google-generativeai
+asyncio-throttle

run.py

@@ -0,0 +1,47 @@
+#!/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/query_planner.py

@@ -0,0 +1,89 @@
+from typing import Dict, Any, List
+import asyncio
+
+class QueryPlanner:
+    def __init__(self, llm):
+        self.llm = llm
+    
+    async def plan_research(self, query: str) -> Dict[str, Any]:
+        try:
+            planning_prompt = f"""
+            Analyze this research query and create a structured plan:
+            Query: {query}
+            
+            Determine:
+            1. What type of analysis is needed (price, market, defi, comparison, etc.)
+            2. Which data sources would be most relevant
+            3. What specific steps should be taken
+            4. Priority focus area
+            
+            Respond in JSON format with keys: type, steps, priority, data_sources
+            """
+            
+            response = await asyncio.to_thread(
+                self.llm.invoke,
+                planning_prompt
+            )
+            
+            # Simple categorization based on keywords
+            query_lower = query.lower()
+            plan = {
+                "type": self._categorize_query(query_lower),
+                "steps": self._generate_steps(query_lower),
+                "priority": self._determine_priority(query_lower),
+                "data_sources": self._identify_sources(query_lower)
+            }
+            
+            return plan
+            
+        except Exception:
+            return {
+                "type": "general",
+                "steps": ["Analyze query", "Gather data", "Provide insights"],
+                "priority": "general analysis",
+                "data_sources": ["coingecko", "defillama"]
+            }
+    
+    def _categorize_query(self, query: str) -> str:
+        if any(word in query for word in ["price", "chart", "value"]):
+            return "price_analysis"
+        elif any(word in query for word in ["defi", "tvl", "protocol", "yield"]):
+            return "defi_analysis"
+        elif any(word in query for word in ["compare", "vs", "versus"]):
+            return "comparison"
+        elif any(word in query for word in ["market", "overview", "trending"]):
+            return "market_overview"
+        else:
+            return "general"
+    
+    def _generate_steps(self, query: str) -> List[str]:
+        steps = ["Gather relevant data"]
+        
+        if "price" in query:
+            steps.extend(["Get current price data", "Analyze price trends"])
+        if "defi" in query:
+            steps.extend(["Fetch DeFi protocol data", "Analyze TVL trends"])
+        if any(word in query for word in ["compare", "vs"]):
+            steps.append("Perform comparative analysis")
+        
+        steps.append("Synthesize insights and recommendations")
+        return steps
+    
+    def _determine_priority(self, query: str) -> str:
+        if "urgent" in query or "now" in query:
+            return "high"
+        elif "overview" in query:
+            return "comprehensive"
+        else:
+            return "standard"
+    
+    def _identify_sources(self, query: str) -> List[str]:
+        sources = []
+        if any(word in query for word in ["price", "market", "coin", "token"]):
+            sources.append("coingecko")
+        if any(word in query for word in ["defi", "tvl", "protocol"]):
+            sources.append("defillama")
+        if any(word in query for word in ["transaction", "address", "gas"]):
+            sources.append("etherscan")
+        
+        return sources if sources else ["coingecko", "defillama"]

src/agent/research_agent.py

@@ -0,0 +1,138 @@
+from langchain.agents import AgentExecutor, create_tool_calling_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 datetime import datetime
+
+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.logger import get_logger
+
+logger = get_logger(__name__)
+
+class Web3ResearchAgent:
+    def __init__(self):
+        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,
+                temperature=0.1,
+                max_tokens=2048
+            )
+            
+            self.tools = [CoinGeckoTool(), DeFiLlamaTool(), EtherscanTool()]
+            self.query_planner = QueryPlanner(self.llm)
+            self.memory = ConversationBufferWindowMemory(
+                memory_key="chat_history", return_messages=True, k=10
+            )
+            
+            self.agent = self._create_agent()
+            self.executor = AgentExecutor(
+                agent=self.agent, tools=self.tools, memory=self.memory,
+                verbose=False, max_iterations=5, handle_parsing_errors=True
+            )
+        except Exception as e:
+            logger.error(f"Agent init failed: {e}")
+            raise
+    
+    def _create_agent(self):
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", """You are an expert Web3 research assistant. Use available tools to provide accurate, 
+            data-driven insights about cryptocurrency markets, DeFi protocols, and blockchain data.
+            
+            Format responses with clear sections, emojis, and actionable insights."""),
+            MessagesPlaceholder("chat_history"),
+            ("human", "{input}"),
+            MessagesPlaceholder("agent_scratchpad")
+        ])
+        
+        return create_tool_calling_agent(self.llm, self.tools, prompt)
+    
+    async def research_query(self, query: str) -> Dict[str, Any]:
+        try:
+            logger.info(f"Processing: {query}")
+            
+            research_plan = await self.query_planner.plan_research(query)
+            
+            enhanced_query = f"""
+            Research Query: {query}
+            Research Plan: {research_plan.get('steps', [])}
+            Priority: {research_plan.get('priority', 'general')}
+            
+            Execute systematic research and provide comprehensive analysis.
+            """
+            
+            result = await asyncio.to_thread(
+                self.executor.invoke, {"input": enhanced_query}
+            )
+            
+            return {
+                "success": True,
+                "query": query,
+                "research_plan": research_plan,
+                "result": result.get("output", "No response"),
+                "sources": self._extract_sources(result.get("output", "")),
+                "metadata": {
+                    "tools_used": [tool.name for tool in self.tools],
+                    "timestamp": datetime.now().isoformat()
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"Research error: {e}")
+            return {
+                "success": False,
+                "query": query,
+                "error": str(e),
+                "metadata": {"timestamp": datetime.now().isoformat()}
+            }
+    
+    async def get_price_history(self, symbol: str, days: int = 30) -> Dict[str, Any]:
+        try:
+            coingecko_tool = next(t for t in self.tools if isinstance(t, CoinGeckoTool))
+            return await coingecko_tool._arun(symbol, {"type": "price_history", "days": days})
+        except Exception as e:
+            logger.error(f"Price history error: {e}")
+            return {}
+    
+    async def get_comprehensive_market_data(self) -> Dict[str, Any]:
+        try:
+            tasks = []
+            for tool in self.tools:
+                if isinstance(tool, CoinGeckoTool):
+                    tasks.append(tool._arun("", {"type": "market_overview"}))
+                elif isinstance(tool, DeFiLlamaTool):
+                    tasks.append(tool._arun("", {"type": "tvl_overview"}))
+            
+            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"] = result
+                    elif i == 1:
+                        data["defi"] = result
+            
+            return data
+        except Exception as e:
+            logger.error(f"Market data error: {e}")
+            return {}
+    
+    def _extract_sources(self, result_text: str) -> List[str]:
+        sources = []
+        if "CoinGecko" in result_text or "coingecko" in result_text.lower():
+            sources.append("CoinGecko API")
+        if "DeFiLlama" in result_text or "defillama" in result_text.lower():
+            sources.append("DeFiLlama API") 
+        if "Etherscan" in result_text or "etherscan" in result_text.lower():
+            sources.append("Etherscan API")
+        return sources

src/api/airaa_integration.py

@@ -0,0 +1,93 @@
+import aiohttp
+import re
+from typing import Dict, Any, List
+from src.config import config
+from src.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+class AIRAAIntegration:
+    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:
+        if not self.enabled:
+            return False
+        
+        try:
+            payload = self._format_for_airaa(research_result)
+            
+            headers = {"Content-Type": "application/json"}
+            if self.api_key:
+                headers["Authorization"] = f"Bearer {self.api_key}"
+            
+            timeout = aiohttp.ClientTimeout(total=30)
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.post(
+                    self.webhook_url, json=payload, headers=headers
+                ) as response:
+                    success = response.status == 200
+                    if success:
+                        logger.info("Data sent to AIRAA successfully")
+                    else:
+                        logger.warning(f"AIRAA webhook returned {response.status}")
+                    return success
+                    
+        except Exception as e:
+            logger.error(f"AIRAA integration failed: {e}")
+            return False
+    
+    def _format_for_airaa(self, result: Dict[str, Any]) -> Dict[str, Any]:
+        return {
+            "source": "web3-research-copilot",
+            "timestamp": result["metadata"]["timestamp"],
+            "query": result["query"],
+            "research_plan": result.get("research_plan", {}),
+            "findings": result["result"],
+            "data_sources": result["sources"],
+            "confidence_score": self._calculate_confidence(result),
+            "tags": self._extract_tags(result["query"]),
+            "structured_data": self._extract_structured_data(result["result"])
+        }
+    
+    def _calculate_confidence(self, result: Dict[str, Any]) -> float:
+        base_score = 0.7
+        source_boost = min(len(result.get("sources", [])) * 0.1, 0.3)
+        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]:
+        tags = []
+        query_lower = query.lower()
+        
+        token_patterns = {
+            "bitcoin": ["bitcoin", "btc"],
+            "ethereum": ["ethereum", "eth"],
+            "defi": ["defi", "defillama", "protocol", "tvl"],
+            "market-analysis": ["price", "market", "analysis"],
+            "trading-volume": ["volume", "trading"]
+        }
+        
+        for tag, patterns in token_patterns.items():
+            if any(pattern in query_lower for pattern in patterns):
+                tags.append(tag)
+        
+        return tags
+    
+    def _extract_structured_data(self, result_text: str) -> Dict[str, Any]:
+        structured = {}
+        
+        price_pattern = r'\$([0-9,]+\.?[0-9]*)'
+        percentage_pattern = r'([+-]?[0-9]+\.?[0-9]*)%'
+        
+        prices = re.findall(price_pattern, result_text)
+        percentages = re.findall(percentage_pattern, result_text)
+        
+        if prices:
+            structured["prices"] = [float(p.replace(',', '')) for p in prices[:5]]
+        if percentages:
+            structured["percentages"] = [float(p) for p in percentages[:5]]
+        
+        return structured

src/config.py

@@ -7,6 +7,7 @@ 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"
@@ -15,5 +16,11 @@ class Config:
     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/tools/base_tool.py

@@ -0,0 +1,64 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+from langchain.tools import BaseTool
+from pydantic import BaseModel, Field, PrivateAttr
+import asyncio
+import aiohttp
+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="Search query or parameter")
+    filters: Optional[Dict[str, Any]] = Field(default=None, description="Additional filters")
+
+class BaseWeb3Tool(BaseTool, ABC):
+    name: str = "base_web3_tool"
+    description: str = "Base Web3 tool"
+    args_schema: type[BaseModel] = Web3ToolInput
+    
+    _session: Optional[aiohttp.ClientSession] = PrivateAttr(default=None)
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._session = None
+    
+    async def get_session(self):
+        if not self._session:
+            timeout = aiohttp.ClientTimeout(total=30)
+            self._session = aiohttp.ClientSession(timeout=timeout)
+        return self._session
+    
+    @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]:
+        session = await self.get_session()
+        try:
+            async with session.get(url, params=params or {}) as response:
+                if response.status == 200:
+                    return await response.json()
+                elif response.status == 429:
+                    await asyncio.sleep(2)
+                    raise aiohttp.ClientResponseError(
+                        request_info=response.request_info,
+                        history=response.history,
+                        status=response.status
+                    )
+                else:
+                    response.raise_for_status()
+        except Exception as e:
+            logger.error(f"Request failed: {e}")
+            raise
+    
+    def _run(self, query: str, filters: Optional[Dict[str, Any]] = None) -> str:
+        return asyncio.run(self._arun(query, filters))
+    
+    @abstractmethod
+    async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None) -> str:
+        pass
+
+    async def cleanup(self):
+        if self._session:
+            await self._session.close()
+        if self.session:
+            await self.session.close()

src/tools/coingecko_tool.py

@@ -0,0 +1,116 @@
+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
+
+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."""
+    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", 
+        "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:
+        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))
+            else:
+                return await self._get_coin_data(query)
+                
+        except Exception as e:
+            return f"CoinGecko error: {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
+    
+    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"
+        
+        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",
+            "include_24hr_change": "true",
+            "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
+    
+        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)
+        
+        return {
+            "symbol": symbol.upper(),
+            "prices": data.get("prices", []),
+            "volumes": data.get("total_volumes", []),
+            "market_caps": data.get("market_caps", [])
+        }

src/tools/defillama_tool.py

@@ -0,0 +1,129 @@
+from typing import Dict, Any, Optional
+from pydantic import BaseModel, PrivateAttr
+from src.tools.base_tool import BaseWeb3Tool, Web3ToolInput
+
+class DeFiLlamaTool(BaseWeb3Tool):
+    name: str = "defillama_data"
+    description: str = """Get DeFi protocol data, TVL, and yields from DeFiLlama.
+    Useful for: DeFi analysis, protocol rankings, TVL trends, yield farming data.
+    Input: protocol name or general DeFi query."""
+    args_schema: type[BaseModel] = Web3ToolInput
+    
+    _base_url: str = PrivateAttr(default="https://api.llama.fi")
+    
+    def __init__(self):
+        super().__init__()
+    
+    async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None) -> str:
+        try:
+            filters = filters or {}
+            
+            if filters.get("type") == "tvl_overview":
+                return await self._get_tvl_overview()
+            elif filters.get("type") == "protocol_data":
+                return await self._get_protocol_data(query)
+            elif query:
+                return await self._search_protocols(query)
+            else:
+                return await self._get_top_protocols()
+                
+        except Exception as e:
+            return f"DeFiLlama error: {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")
+            
+            emoji = "📈" if change >= 0 else "📉"
+            result += f"{i}. **{name}** ({chain}): ${tvl/1e9:.2f}B TVL {emoji} ({change:+.2f}%)\n"
+        
+        return result
+    
+    async def _get_tvl_overview(self) -> str:
+        try:
+            protocols_data = await self.make_request(f"{self.base_url}/protocols")
+            chains_data = await self.make_request(f"{self.base_url}/chains")
+            
+            if not protocols_data or not chains_data:
+                return "TVL overview data unavailable"
+            
+            total_tvl = sum(p.get("tvl", 0) for p in protocols_data)
+            top_chains = sorted(chains_data, key=lambda x: x.get("tvl", 0), reverse=True)[:5]
+            
+            result = "🌐 **DeFi TVL Overview:**\n\n"
+            result += f"💰 **Total TVL**: ${total_tvl/1e9:.2f}B\n\n"
+            result += "**Top Chains by TVL:**\n"
+            
+            for i, chain in enumerate(top_chains, 1):
+                name = chain.get("name", "Unknown")
+                tvl = chain.get("tvl", 0)
+                result += f"{i}. **{name}**: ${tvl/1e9:.2f}B\n"
+            
+            return result
+            
+        except Exception:
+            return await self._get_top_protocols()
+    
+    async def _get_protocol_data(self, protocol: str) -> str:
+        protocols = await self.make_request(f"{self.base_url}/protocols")
+        
+        if not protocols:
+            return f"No data available for {protocol}"
+        
+        matching_protocol = None
+        for p in protocols:
+            if protocol.lower() in p.get("name", "").lower():
+                matching_protocol = p
+                break
+        
+        if not matching_protocol:
+            return f"Protocol '{protocol}' not found"
+        
+        name = matching_protocol.get("name", "Unknown")
+        tvl = matching_protocol.get("tvl", 0)
+        change_1d = matching_protocol.get("change_1d", 0)
+        change_7d = matching_protocol.get("change_7d", 0)
+        chain = matching_protocol.get("chain", "Multi-chain")
+        category = matching_protocol.get("category", "Unknown")
+        
+        result = f"🏛️ **{name} Protocol Analysis:**\n\n"
+        result += f"💰 **TVL**: ${tvl/1e9:.2f}B\n"
+        result += f"📊 **24h Change**: {change_1d:+.2f}%\n"
+        result += f"📈 **7d Change**: {change_7d:+.2f}%\n"
+        result += f"⛓️ **Chain**: {chain}\n"
+        result += f"🏷️ **Category**: {category}\n"
+        
+        return result
+    
+    async def _search_protocols(self, query: str) -> str:
+        protocols = await self.make_request(f"{self.base_url}/protocols")
+        
+        if not protocols:
+            return "No protocol data available"
+        
+        matching = [p for p in protocols if query.lower() in p.get("name", "").lower()][:5]
+        
+        if not matching:
+            return f"No protocols found matching '{query}'"
+        
+        result = f"🔍 **Protocols matching '{query}':**\n\n"
+        
+        for protocol in matching:
+            name = protocol.get("name", "Unknown")
+            tvl = protocol.get("tvl", 0)
+            chain = protocol.get("chain", "Multi-chain")
+            result += f"• **{name}** ({chain}): ${tvl/1e9:.2f}B TVL\n"
+        
+        return result

src/tools/etherscan_tool.py

@@ -0,0 +1,138 @@
+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
+
+class EtherscanTool(BaseWeb3Tool):
+    name: str = "etherscan_data"
+    description: str = """Get Ethereum blockchain data from Etherscan.
+    Useful for: transaction analysis, address information, gas prices, token data.
+    Input: Ethereum address, transaction hash, or general blockchain query."""
+    args_schema: type[BaseModel] = Web3ToolInput
+    
+    _base_url: str = PrivateAttr(default="https://api.etherscan.io/api")
+    _api_key: Optional[str] = PrivateAttr(default=None)
+    
+    def __init__(self):
+        super().__init__()
+        self._api_key = config.ETHERSCAN_API_KEY
+    
+    async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None) -> str:
+        if not self.api_key:
+            return "❌ Etherscan API key not configured"
+        
+        try:
+            filters = filters or {}
+            
+            if filters.get("type") == "gas_prices":
+                return await self._get_gas_prices()
+            elif filters.get("type") == "eth_stats":
+                return await self._get_eth_stats()
+            elif self._is_address(query):
+                return await self._get_address_info(query)
+            elif self._is_tx_hash(query):
+                return await self._get_transaction_info(query)
+            else:
+                return await self._get_gas_prices()
+                
+        except Exception as e:
+            return f"Etherscan error: {str(e)}"
+    
+    def _is_address(self, query: str) -> bool:
+        return len(query) == 42 and query.startswith("0x")
+    
+    def _is_tx_hash(self, query: str) -> bool:
+        return len(query) == 66 and query.startswith("0x")
+    
+    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
+    
+    async def _get_eth_stats(self) -> str:
+        params = {
+            "module": "stats",
+            "action": "ethsupply",
+            "apikey": self.api_key
+        }
+        
+        data = await self.make_request(self.base_url, params)
+        
+        if data.get("status") != "1":
+            return "Ethereum stats unavailable"
+        
+        eth_supply = int(data.get("result", 0)) / 1e18
+        
+        result = "📊 **Ethereum Network Stats:**\n\n"
+        result += f"💎 **ETH Supply**: {eth_supply:,.0f} ETH\n"
+        
+        return result
+    
+    async def _get_address_info(self, address: str) -> str:
+        params = {
+            "module": "account",
+            "action": "balance", 
+            "address": address,
+            "tag": "latest",
+            "apikey": self.api_key
+        }
+        
+        data = await self.make_request(self.base_url, params)
+        
+        if data.get("status") != "1":
+            return f"Address information unavailable for {address}"
+        
+        balance_wei = int(data.get("result", 0))
+        balance_eth = balance_wei / 1e18
+        
+        result = f"📍 **Address Information:**\n\n"
+        result += f"**Address**: {address}\n"
+        result += f"💰 **Balance**: {balance_eth:.4f} ETH\n"
+        
+        return result
+    
+    async def _get_transaction_info(self, tx_hash: str) -> str:
+        params = {
+            "module": "proxy",
+            "action": "eth_getTransactionByHash",
+            "txhash": tx_hash,
+            "apikey": self.api_key
+        }
+        
+        data = await self.make_request(self.base_url, params)
+        
+        if not data.get("result"):
+            return f"Transaction not found: {tx_hash}"
+        
+        tx = data.get("result", {})
+        value_wei = int(tx.get("value", "0x0"), 16)
+        value_eth = value_wei / 1e18
+        gas_price = int(tx.get("gasPrice", "0x0"), 16) / 1e9
+        
+        result = f"📝 **Transaction Information:**\n\n"
+        result += f"**Hash**: {tx_hash}\n"
+        result += f"**From**: {tx.get('from', 'N/A')}\n"
+        result += f"**To**: {tx.get('to', 'N/A')}\n"
+        result += f"💰 **Value**: {value_eth:.4f} ETH\n"
+        result += f"⛽ **Gas Price**: {gas_price:.2f} gwei\n"
+        
+        return result

src/utils/config.py

@@ -0,0 +1 @@
+from src.config import config

src/utils/exceptions.py

@@ -0,0 +1,16 @@
+from typing import Dict, Any
+
+class CustomException(Exception):
+    pass
+
+class APIError(CustomException):
+    pass
+
+class RateLimitError(APIError):
+    pass
+
+class DataValidationError(CustomException):
+    pass
+
+class ConfigurationError(CustomException):
+    pass

src/utils/logger.py

@@ -0,0 +1,17 @@
+import logging
+import sys
+from typing import Optional
+
+def get_logger(name: str, level: str = "INFO") -> logging.Logger:
+    logger = logging.getLogger(name)
+    
+    if not logger.handlers:
+        handler = logging.StreamHandler(sys.stdout)
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        logger.setLevel(getattr(logging, level.upper()))
+    
+    return logger

src/visualizations.py

@@ -1,238 +1,62 @@
 import plotly.graph_objects as go
-import plotly.express as px
-from plotly.subplots import make_subplots
-from typing import Dict, Any, List
-import pandas as pd
 from datetime import datetime
+from typing import Dict, Any
 
-def create_price_chart(data: Dict[str, Any], symbol: str) -> str:
+def create_price_chart(data: Dict[str, Any], symbol: str) -> go.Figure:
     try:
         if not data or "prices" not in data:
-            return f"<div style='padding: 20px; text-align: center;'>No price data available for {symbol.upper()}</div>"
+            return _empty_chart(f"No price data for {symbol}")
         
         prices = data["prices"]
-        volumes = data.get("total_volumes", [])
+        timestamps = [datetime.fromtimestamp(p[0]/1000) for p in prices]
+        values = [p[1] for p in prices]
         
-        if not prices:
-            return f"<div style='padding: 20px; text-align: center;'>No price history found for {symbol.upper()}</div>"
-        
-        df = pd.DataFrame(prices, columns=["timestamp", "price"])
-        df["datetime"] = pd.to_datetime(df["timestamp"], unit="ms")
-        
-        fig = make_subplots(
-            rows=2, cols=1,
-            shared_xaxes=True,
-            vertical_spacing=0.05,
-            subplot_titles=[f"{symbol.upper()} Price Chart", "Volume"],
-            row_width=[0.7, 0.3]
-        )
-        
-        fig.add_trace(
-            go.Scatter(
-                x=df["datetime"],
-                y=df["price"],
-                mode="lines",
-                name="Price",
-                line=dict(color="#00D4AA", width=2),
-                hovertemplate="<b>%{y:$,.2f}</b><br>%{x}<extra></extra>"
-            ),
-            row=1, col=1
-        )
-        
-        if volumes:
-            vol_df = pd.DataFrame(volumes, columns=["timestamp", "volume"])
-            vol_df["datetime"] = pd.to_datetime(vol_df["timestamp"], unit="ms")
-            
-            fig.add_trace(
-                go.Bar(
-                    x=vol_df["datetime"],
-                    y=vol_df["volume"],
-                    name="Volume",
-                    marker_color="#FF6B6B",
-                    opacity=0.7,
-                    hovertemplate="<b>$%{y:,.0f}</b><br>%{x}<extra></extra>"
-                ),
-                row=2, col=1
-            )
-        
-        current_price = df["price"].iloc[-1]
-        price_change = ((df["price"].iloc[-1] - df["price"].iloc[0]) / df["price"].iloc[0]) * 100
+        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=dict(
-                text=f"{symbol.upper()} - ${current_price:,.4f} ({price_change:+.2f}%)",
-                x=0.5,
-                font=dict(size=20, color="#FFFFFF")
-            ),
-            xaxis_title="Date",
-            yaxis_title="Price (USD)",
-            template="plotly_dark",
-            showlegend=False,
-            height=600,
-            margin=dict(l=60, r=60, t=80, b=60),
-            plot_bgcolor="rgba(0,0,0,0)",
-            paper_bgcolor="rgba(0,0,0,0)"
+            title=f'{symbol.upper()} Price History',
+            xaxis_title='Date', yaxis_title='Price (USD)',
+            template='plotly_dark', height=400
         )
         
-        fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor="rgba(255,255,255,0.1)")
-        fig.update_yaxes(showgrid=True, gridwidth=1, gridcolor="rgba(255,255,255,0.1)")
-        
-        return fig.to_html(include_plotlyjs="cdn", div_id=f"chart_{symbol}")
-        
-    except Exception as e:
-        return f"<div style='padding: 20px; text-align: center; color: #FF6B6B;'>Chart generation failed: {str(e)}</div>"
+        return fig
+    except Exception:
+        return _empty_chart(f"Chart error for {symbol}")
 
-def create_market_overview(data: Dict[str, Any]) -> str:
+def create_market_overview(data: Dict[str, Any]) -> go.Figure:
     try:
-        if not data or "market_data" not in data:
-            return "<div style='padding: 20px; text-align: center;'>Market data unavailable</div>"
-        
-        market_data = data["market_data"]
-        if not market_data:
-            return "<div style='padding: 20px; text-align: center;'>No market data found</div>"
-        
-        df = pd.DataFrame(market_data)
-        df = df.head(20)
-        
-        fig = make_subplots(
-            rows=2, cols=2,
-            subplot_titles=[
-                "Market Cap Distribution",
-                "24h Price Changes",
-                "Trading Volume",
-                "Price vs Volume"
-            ],
-            specs=[[{"type": "pie"}, {"type": "bar"}],
-                   [{"type": "bar"}, {"type": "scatter"}]]
-        )
-        
-        fig.add_trace(
-            go.Pie(
-                labels=df["symbol"].str.upper(),
-                values=df["market_cap"],
-                textinfo="label+percent",
-                textposition="inside",
-                marker=dict(colors=px.colors.qualitative.Set3),
-                hovertemplate="<b>%{label}</b><br>Market Cap: $%{value:,.0f}<extra></extra>"
-            ),
-            row=1, col=1
-        )
-        
-        colors = ["#00D4AA" if x >= 0 else "#FF6B6B" for x in df["price_change_percentage_24h"]]
-        fig.add_trace(
-            go.Bar(
-                x=df["symbol"].str.upper(),
-                y=df["price_change_percentage_24h"],
-                marker_color=colors,
-                hovertemplate="<b>%{x}</b><br>24h Change: %{y:+.2f}%<extra></extra>"
-            ),
-            row=1, col=2
-        )
+        if not data:
+            return _empty_chart("No market data available")
         
-        fig.add_trace(
-            go.Bar(
-                x=df["symbol"].str.upper(),
-                y=df["total_volume"],
-                marker_color="#4ECDC4",
-                hovertemplate="<b>%{x}</b><br>Volume: $%{y:,.0f}<extra></extra>"
-            ),
-            row=2, col=1
+        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.add_trace(
-            go.Scatter(
-                x=df["current_price"],
-                y=df["total_volume"],
-                mode="markers+text",
-                text=df["symbol"].str.upper(),
-                textposition="top center",
-                marker=dict(
-                    size=df["market_cap"] / df["market_cap"].max() * 50 + 10,
-                    color=df["price_change_percentage_24h"],
-                    colorscale="RdYlGn",
-                    colorbar=dict(title="24h Change %"),
-                    line=dict(width=1, color="white")
-                ),
-                hovertemplate="<b>%{text}</b><br>Price: $%{x:,.4f}<br>Volume: $%{y:,.0f}<extra></extra>"
-            ),
-            row=2, col=2
-        )
-        
-        global_info = data.get("global_data", {}).get("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)
-        
-        title_text = f"Crypto Market Overview - Total MCap: ${total_mcap/1e12:.2f}T | 24h Vol: ${total_volume/1e9:.0f}B | BTC Dom: {btc_dominance:.1f}%"
-        
         fig.update_layout(
-            title=dict(
-                text=title_text,
-                x=0.5,
-                font=dict(size=16, color="#FFFFFF")
-            ),
-            template="plotly_dark",
-            showlegend=False,
-            height=800,
-            margin=dict(l=60, r=60, t=100, b=60),
-            plot_bgcolor="rgba(0,0,0,0)",
-            paper_bgcolor="rgba(0,0,0,0)"
+            title="Market Overview", template='plotly_dark', height=400,
+            xaxis=dict(visible=False), yaxis=dict(visible=False)
         )
         
-        fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor="rgba(255,255,255,0.1)")
-        fig.update_yaxes(showgrid=True, gridwidth=1, gridcolor="rgba(255,255,255,0.1)")
-        
-        return fig.to_html(include_plotlyjs="cdn", div_id="market_overview")
-        
-    except Exception as e:
-        return f"<div style='padding: 20px; text-align: center; color: #FF6B6B;'>Market overview failed: {str(e)}</div>"
+        return fig
+    except Exception:
+        return _empty_chart("Market overview error")
 
-def create_comparison_chart(coins_data: List[Dict[str, Any]]) -> str:
-    try:
-        if not coins_data:
-            return "<div style='padding: 20px; text-align: center;'>No comparison data available</div>"
-        
-        df = pd.DataFrame(coins_data)
-        
-        fig = make_subplots(
-            rows=1, cols=2,
-            subplot_titles=["Price Comparison", "Market Cap Comparison"]
-        )
-        
-        colors = px.colors.qualitative.Set1[:len(df)]
-        
-        for i, (_, coin) in enumerate(df.iterrows()):
-            fig.add_trace(
-                go.Bar(
-                    name=coin["symbol"].upper(),
-                    x=[coin["symbol"].upper()],
-                    y=[coin["current_price"]],
-                    marker_color=colors[i],
-                    hovertemplate=f"<b>{coin['name']}</b><br>Price: $%{{y:,.4f}}<extra></extra>"
-                ),
-                row=1, col=1
-            )
-            
-            fig.add_trace(
-                go.Bar(
-                    name=coin["symbol"].upper(),
-                    x=[coin["symbol"].upper()],
-                    y=[coin["market_cap"]],
-                    marker_color=colors[i],
-                    showlegend=False,
-                    hovertemplate=f"<b>{coin['name']}</b><br>Market Cap: $%{{y:,.0f}}<extra></extra>"
-                ),
-                row=1, col=2
-            )
-        
-        fig.update_layout(
-            title="Cryptocurrency Comparison",
-            template="plotly_dark",
-            height=500,
-            showlegend=True
-        )
-        
-        return fig.to_html(include_plotlyjs="cdn", div_id="comparison_chart")
-        
-    except Exception as e:
-        return f"<div style='padding: 20px; text-align: center; color: #FF6B6B;'>Comparison chart failed: {str(e)}</div>"
+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

@@ -0,0 +1,108 @@
+#!/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!")