Resolved conflicts by keeping HuggingFace versions

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,11 +1,38 @@
+# Byte-compiled / optimized / DLL files
 __pycache__/
+*.py[cod]
+*$py.class
 *.pyc
 *.pyo
 *.pyd
+
+# Distribution / packaging
 .Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
 env/
 venv/
 .venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Testing / coverage
 pip-log.txt
 pip-delete-this-directory.txt
 .tox/
@@ -15,15 +42,41 @@ pip-delete-this-directory.txt
 nosetests.xml
 coverage.xml
 *.cover
-*.log
-.git
-.mypy_cache
 .pytest_cache
 .hypothesis
 
+# Logs
+*.log
+
+# mypy
+.mypy_cache
+.git
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
 .DS_Store
+Thumbs.db
+
+# Environment files
 .env
 .flaskenv
 *.env
 
+# Application specific
 gradio_queue.db
+user_sessions/
+temp_data/
+cache/
+
+# Ollama models cache (large files)
+.ollama/
+
+# Local configuration
+config.local.*
+.env.local

Dockerfile

@@ -1,37 +1,108 @@
-# Use Python 3.11 slim image for HuggingFace Spaces
+# Multi-stage Dockerfile for HuggingFace Spaces with Ollama
 FROM python:3.11-slim
 
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV DEBIAN_FRONTEND=noninteractive
+ENV OLLAMA_HOST=0.0.0.0
+ENV OLLAMA_PORT=11434
+ENV OLLAMA_HOME=/app/.ollama
+ENV HOME=/app
+ENV PYTHONPATH=/app
+
 # Set working directory
 WORKDIR /app
 
-# Install system dependencies
+# Install system dependencies including Ollama requirements
 RUN apt-get update && apt-get install -y \
     curl \
+    wget \
+    build-essential \
+    git \
     && rm -rf /var/lib/apt/lists/*
 
-# Copy requirements first for better caching
-COPY requirements.txt .
+# Install Ollama
+RUN curl -fsSL https://ollama.ai/install.sh | sh
 
-# Install Python dependencies
-RUN pip install --no-cache-dir --upgrade pip && \
-    pip install --no-cache-dir -r requirements.txt
+# Copy requirements first for better Docker caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
 # Copy application code
 COPY . .
 
-# Create necessary directories
-RUN mkdir -p logs cache
+# Create necessary directories including Ollama data directory
+RUN mkdir -p logs cache templates static $OLLAMA_HOME \
+    && chown -R 1000:1000 /app \
+    && chmod -R 755 /app
 
-# Set environment variables for HuggingFace Spaces
-ENV PYTHONPATH=/app
-ENV PYTHONUNBUFFERED=1
+# Expose ports for both app and Ollama
+EXPOSE 7860 11434
+
+# Create startup script
+RUN echo '#!/bin/bash\n\
+set -e\n\
+echo "🚀 Starting HuggingFace Spaces Web3 Research Co-Pilot..."\n\
+\n\
+# Create Ollama data directory with proper permissions\n\
+echo "🗂️  Setting up Ollama data directory..."\n\
+mkdir -p /app/.ollama\n\
+chmod -R 755 /app/.ollama\n\
+chown -R $(whoami):$(whoami) /app/.ollama 2>/dev/null || true\n\
+echo "Directory created: $(ls -la /app/.ollama)"\n\
+\n\
+# Start Ollama server with explicit home directory\n\
+echo "📦 Starting Ollama server with data directory /app/.ollama..."\n\
+export HOME=/app\n\
+export OLLAMA_HOME=/app/.ollama\n\
+cd /app\n\
+ollama serve &\n\
+OLLAMA_PID=$!\n\
+\n\
+# Wait for Ollama to be ready\n\
+echo "⏳ Waiting for Ollama to be ready..."\n\
+while ! curl -s http://localhost:11434/api/tags > /dev/null; do\n\
+  sleep 2\n\
+  echo "   ... still waiting for Ollama"\n\
+done\n\
+\n\
+echo "✅ Ollama server is ready!"\n\
+\n\
+# Pull the Llama 3.1 8B model\n\
+echo "📥 Pulling llama3.1:8b model (this may take a few minutes)..."\n\
+export HOME=/app\n\
+export OLLAMA_HOME=/app/.ollama\n\
+cd /app\n\
+ollama pull llama3.1:8b\n\
+echo "✅ Model llama3.1:8b ready!"\n\
+\n\
+# Start the main application\n\
+echo "🌐 Starting Web3 Research Co-Pilot web application..."\n\
+echo "🔍 Running startup validation..."\n\
+python validate_startup.py || exit 1\n\
+python app.py &\n\
+APP_PID=$!\n\
+\n\
+# Function to handle shutdown\n\
+cleanup() {\n\
+    echo "🛑 Shutting down gracefully..."\n\
+    kill $APP_PID $OLLAMA_PID 2>/dev/null || true\n\
+    wait $APP_PID $OLLAMA_PID 2>/dev/null || true\n\
+    echo "✅ Shutdown complete"\n\
+}\n\
+\n\
+# Set up signal handlers\n\
+trap cleanup SIGTERM SIGINT\n\
+\n\
+# Wait for processes\n\
+wait $APP_PID $OLLAMA_PID' > start.sh
 
-# Expose port 7860 (HuggingFace Spaces default)
-EXPOSE 7860
+# Make startup script executable
+RUN chmod +x start.sh
 
-# Health check
-HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+# Health check with longer startup time for model download
+HEALTHCHECK --interval=30s --timeout=10s --start-period=600s --retries=3 \
     CMD curl -f http://localhost:7860/health || exit 1
 
-# Run the application
-CMD ["python", "app_fastapi.py"]
+# Start command
+CMD ["./start.sh"]

README.md

@@ -1,129 +1,119 @@
-# 🚀 Web3 Research Co-Pilot
+---
+title: Web3 Research Co-Pilot
+emoji: 🚀
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_file: app.py
+dockerfile: Dockerfile
+license: mit
+tags:
+- cryptocurrency
+- blockchain
+- defi
+- ai-research
+- ollama
+- llama3
+pinned: false
+header: default
+short_description: AI-powered crypto research with real-time blockchain data
+suggested_hardware: t4-medium
+---
 
-AI-powered cryptocurrency research assistant with comprehensive Web3 data analysis capabilities.
+# Web3 Research Co-Pilot 🚀
 
-## Features
+An AI-powered cryptocurrency research assistant that provides real-time blockchain analytics, DeFi insights, and market intelligence using Llama 8B and comprehensive API integrations.
 
-- **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
+## ✨ Features
 
-## Quick Start
+- **🤖 AI-Powered Analysis**: Uses Llama 8B model via Ollama for intelligent responses
+- **🔗 Real-Time Data**: Integrates with CryptoCompare, DeFiLlama, Etherscan APIs
+- **🛡️ AI Safety**: Built-in content filtering and safety guardrails
+- **📊 Interactive UI**: Modern web interface with dark/light themes
+- **⚡ Streaming Responses**: Real-time progress updates during analysis
+- **🔄 Comprehensive Tools**: 5+ specialized cryptocurrency research tools
 
-### 1. Environment Setup
+## 🛠️ Technical Stack
 
-```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
-```
+- **Backend**: FastAPI with Python 3.11
+- **AI Model**: Llama 3 8B via Ollama (local inference)
+- **Frontend**: Vanilla JavaScript with modern CSS
+- **APIs**: CryptoCompare, DeFiLlama, Etherscan, CoinGecko
+- **Safety**: Custom AI safety module with content filtering
+- **Deployment**: Docker for HuggingFace Spaces
 
-### 2. Installation
+## 🚀 Usage
 
-```bash
-pip install -r requirements.txt
-```
+Ask questions like:
+- "Analyze Bitcoin price trends and institutional adoption patterns"
+- "Compare top DeFi protocols by TVL and yield metrics"
+- "What are the current Ethereum gas fees?"
+- "Track whale movements in Bitcoin today"
 
-### 3. Launch
+## 🔧 Development
 
+### Local Setup
 ```bash
-python launch.py
-```
-
-## API Keys
+# Clone the repository
+git clone https://huggingface.co/spaces/your-username/web3-research-copilot
+cd web3-research-copilot
 
-- **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)
+# Install dependencies
+pip install -r requirements.txt
 
-## Architecture
+# Start Ollama (in separate terminal)
+ollama serve
+ollama pull llama3:8b
 
+# Run the application
+python app.py
 ```
-├── 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
-
-- **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**
+### Docker Deployment
 ```bash
-git clone <repository-url>
-cd web3-research-agent
-pip install -r requirements.txt
+# Build and run with Docker
+docker build -f Dockerfile.hf -t web3-copilot .
+docker run -p 7860:7860 -p 11434:11434 web3-copilot
 ```
 
-2. **Environment Configuration**
-```bash
-cp .env.example .env
-# Edit .env with your API keys
-```
+## 📁 Project Structure
 
-3. **Run Application**
-```bash
-python app.py
+```
+├── app.py                 # Main FastAPI application
+├── templates/             # HTML templates
+├── static/               # CSS and JavaScript files
+├── src/
+│   ├── agent/            # AI research agent
+│   ├── tools/            # API integration tools
+│   └── utils/            # Configuration and safety
+├── Dockerfile.hf         # HuggingFace Spaces Docker config
+└── requirements.txt      # Python dependencies
 ```
 
-## Required API Keys
+## 🛡️ AI Safety Features
 
-- `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)
+- Input sanitization and validation
+- Rate limiting protection
+- Content filtering for harmful requests
+- Response safety validation
+- Comprehensive logging for monitoring
 
-## Deployment
+## 📊 Supported APIs
 
-### Docker
-```bash
-docker build -t web3-research-agent .
-docker run -p 7860:7860 --env-file .env web3-research-agent
-```
+- **CryptoCompare**: Price data and market statistics
+- **DeFiLlama**: Protocol TVL and DeFi analytics  
+- **Etherscan**: Ethereum network data and gas prices
+- **CoinGecko**: Cryptocurrency market data
+- **Custom Chart Data**: Historical price analysis
 
-### Hugging Face Spaces
-Upload repository to HF Spaces with environment variables configured.
+## 🤝 Contributing
 
-## Architecture
+This project implements responsible AI practices and focuses on legitimate cryptocurrency research and education.
 
-- **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
+## 📄 License
 
-## Usage Examples
+MIT License - see LICENSE file for details
 
-- "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
+Built with ❤️ for the crypto research community

app.py

@@ -1,11 +1,12 @@
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
-from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse
 from pydantic import BaseModel
 import asyncio
 import json
 from datetime import datetime
+import time
 from typing import List, Dict, Any, Optional
 import os
 from dotenv import load_dotenv
@@ -28,10 +29,15 @@ app = FastAPI(
     version="2.0.0"
 )
 
+# Mount static files and templates
+app.mount("/static", StaticFiles(directory="static"), name="static")
+templates = Jinja2Templates(directory="templates")
+
 # Pydantic models
 class QueryRequest(BaseModel):
     query: str
     chat_history: Optional[List[Dict[str, str]]] = []
+    use_gemini: bool = False
 
 class QueryResponse(BaseModel):
     success: bool
@@ -44,44 +50,57 @@ class QueryResponse(BaseModel):
 class Web3CoPilotService:
     def __init__(self):
         try:
-            logger.info("Initializing Web3 Research Co-Pilot...")
+            logger.info("Initializing Web3 Research Service...")
             
-            if config.GEMINI_API_KEY:
-                logger.info("Initializing AI research agent...")
+            # Initialize research agent (supports Ollama-only mode)
+            if config.USE_OLLAMA_ONLY or config.GEMINI_API_KEY:
+                logger.info("AI research capabilities enabled")
                 self.agent = Web3ResearchAgent()
-                logger.info("AI research agent initialized")
+                self.enabled = self.agent.enabled
             else:
-                logger.warning("GEMINI_API_KEY not configured - limited functionality")
+                logger.info("AI research capabilities disabled - configuration required")
                 self.agent = None
+                self.enabled = False
             
-            logger.info("Initializing integrations...")
-            self.airaa = AIRAAIntegration()
-            
-            self.enabled = bool(config.GEMINI_API_KEY)
-            self.visualizer = CryptoVisualizations()
+            # Initialize integrations
+            logger.info("Initializing external integrations...")
+            try:
+                self.airaa = AIRAAIntegration()
+            except Exception as e:
+                logger.warning("External integration unavailable")
+                self.airaa = None
             
-            logger.info(f"Service initialized (AI enabled: {self.enabled})")
+            # Initialize visualization tools
+            try:
+                self.viz = CryptoVisualizations()
+            except Exception as e:
+                logger.warning("Visualization tools unavailable")
+                self.viz = None
+                
+            logger.info(f"Service initialized successfully (AI enabled: {self.enabled})")
             
         except Exception as e:
-            logger.error(f"Service initialization failed: {e}")
+            logger.error(f"Service initialization failed")
+            self.enabled = False
             self.agent = None
             self.airaa = None
-            self.enabled = False
-            self.visualizer = CryptoVisualizations()
+            self.viz = None
     
-    async def process_query(self, query: str) -> QueryResponse:
-        """Process research query with visualizations"""
-        logger.info(f"Processing query: {query[:100]}...")
+    async def process_query(self, query: str, use_gemini: bool = False) -> QueryResponse:
+        """Process research query with comprehensive analysis"""
+        logger.info("Processing research request...")
         
         if not query.strip():
+            logger.warning("Empty query received")
             return QueryResponse(
-                success=False, 
+                success=False,
                 response="Please provide a research query.", 
                 error="Empty query"
             )
-        
+            
         try:
             if not self.enabled:
+                logger.info("Processing in limited mode")
                 response = """**Research Assistant - Limited Mode**
 
 API access available for basic cryptocurrency data:
@@ -92,43 +111,61 @@ API access available for basic cryptocurrency data:
 Configure GEMINI_API_KEY environment variable for full AI analysis."""
                 return QueryResponse(success=True, response=response, sources=["System"])
             
-            logger.info("Processing with AI research agent...")
-            result = await self.agent.research_query(query)
+            logger.info("🤖 Processing with AI research agent...")
+            logger.info(f"🛠️ Available tools: {[tool.name for tool in self.agent.tools] if self.agent else []}")
+            
+            result = await self.agent.research_query(query, use_gemini=use_gemini)
+            logger.info(f"🔄 Agent research completed: success={result.get('success')}")
             
             if result.get("success"):
                 response = result.get("result", "No analysis generated")
                 sources = result.get("sources", [])
                 metadata = result.get("metadata", {})
                 
-                # Generate visualizations if relevant data is available
+                logger.info(f"📊 Response generated: {len(response)} chars, {len(sources)} sources")
+                
+                # Check for chart data and generate visualizations
                 visualizations = []
+                chart_data = await self._extract_chart_data_from_response(response)
+                if chart_data:
+                    chart_html = await self._generate_chart_from_data(chart_data)
+                    if chart_html:
+                        visualizations.append(chart_html)
+                        logger.info("✅ Chart generated from structured data")
+                
+                # Clean the response for user display
+                cleaned_response = self._clean_agent_response(response)
+                    
+                # Generate visualizations if relevant data is available  
                 if metadata:
+                    logger.info("📈 Checking for visualization data...")
                     vis_html = await self._generate_visualizations(metadata, query)
                     if vis_html:
                         visualizations.append(vis_html)
+                        logger.info("✅ Visualization generated")
                 
                 # Send to AIRAA if enabled
                 if self.airaa and self.airaa.enabled:
                     try:
                         await self.airaa.send_research_data(query, response)
-                        logger.info("Data sent to AIRAA")
+                        logger.info("📤 Data sent to AIRAA")
                     except Exception as e:
-                        logger.warning(f"AIRAA integration failed: {e}")
+                        logger.warning(f"⚠️ AIRAA integration failed: {e}")
                 
                 return QueryResponse(
                     success=True, 
-                    response=response, 
+                    response=cleaned_response, 
                     sources=sources, 
                     metadata=metadata,
                     visualizations=visualizations
                 )
             else:
                 error_msg = result.get("error", "Research analysis failed")
-                logger.error(f"Research failed: {error_msg}")
+                logger.error(f"❌ Research failed: {error_msg}")
                 return QueryResponse(success=False, response=error_msg, error=error_msg)
             
         except Exception as e:
-            logger.error(f"Query processing error: {e}")
+            logger.error(f"💥 Query processing error: {e}", exc_info=True)
             error_msg = f"Processing error: {str(e)}"
             return QueryResponse(success=False, response=error_msg, error=error_msg)
     
@@ -165,616 +202,197 @@ Configure GEMINI_API_KEY environment variable for full AI analysis."""
             if symbol in query_upper:
                 return symbol
         return 'BTC'  # Default
-
-# Initialize service
-service = Web3CoPilotService()
-
-@app.get("/", response_class=HTMLResponse)
-async def get_homepage(request: Request):
-    """Serve minimalist, professional interface"""
-    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 24 24%22><path fill=%22%2300d4aa%22 d=%22M12 2L2 7v10c0 5.5 3.8 7.7 9 9 5.2-1.3 9-3.5 9-9V7l-10-5z%22/></svg>">
-        
-        <style>
-            :root {
-                --primary: #0066ff;
-                --primary-dark: #0052cc;
-                --accent: #00d4aa;
-                --background: #000000;
-                --surface: #111111;
-                --surface-elevated: #1a1a1a;
-                --text: #ffffff;
-                --text-secondary: #a0a0a0;
-                --text-muted: #666666;
-                --border: rgba(255, 255, 255, 0.08);
-                --border-focus: rgba(0, 102, 255, 0.3);
-                --shadow: rgba(0, 0, 0, 0.4);
-                --success: #00d4aa;
-                --warning: #ffa726;
-                --error: #f44336;
-            }
-
-            * {
-                margin: 0;
-                padding: 0;
-                box-sizing: border-box;
-            }
-
-            body {
-                font-family: -apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, sans-serif;
-                background: var(--background);
-                color: var(--text);
-                line-height: 1.5;
-                min-height: 100vh;
-                font-weight: 400;
-                -webkit-font-smoothing: antialiased;
-                -moz-osx-font-smoothing: grayscale;
-            }
-
-            .container {
-                max-width: 1000px;
-                margin: 0 auto;
-                padding: 2rem 1.5rem;
-            }
-
-            .header {
-                text-align: center;
-                margin-bottom: 2.5rem;
-            }
-
-            .header h1 {
-                font-size: 2.25rem;
-                font-weight: 600;
-                color: var(--text);
-                margin-bottom: 0.5rem;
-                letter-spacing: -0.025em;
-            }
-
-            .header .brand {
-                color: var(--primary);
-            }
-
-            .header p {
-                color: var(--text-secondary);
-                font-size: 1rem;
-                font-weight: 400;
-            }
-
-            .status {
-                background: var(--surface);
-                border: 1px solid var(--border);
-                border-radius: 12px;
-                padding: 1rem 1.5rem;
-                margin-bottom: 2rem;
-                text-align: center;
-                transition: all 0.2s ease;
-            }
-
-            .status.online {
-                border-color: var(--success);
-                background: linear-gradient(135deg, rgba(0, 212, 170, 0.05), rgba(0, 212, 170, 0.02));
-            }
-
-            .status.offline {
-                border-color: var(--error);
-                background: linear-gradient(135deg, rgba(244, 67, 54, 0.05), rgba(244, 67, 54, 0.02));
-            }
-
-            .status.checking {
-                border-color: var(--warning);
-                background: linear-gradient(135deg, rgba(255, 167, 38, 0.05), rgba(255, 167, 38, 0.02));
-                animation: pulse 2s infinite;
-            }
-
-            @keyframes pulse {
-                0%, 100% { opacity: 1; }
-                50% { opacity: 0.8; }
-            }
-
-            .chat-interface {
-                background: var(--surface);
-                border: 1px solid var(--border);
-                border-radius: 16px;
-                overflow: hidden;
-                margin-bottom: 2rem;
-                backdrop-filter: blur(20px);
-            }
-
-            .chat-messages {
-                height: 480px;
-                overflow-y: auto;
-                padding: 2rem;
-                background: linear-gradient(180deg, var(--background), var(--surface));
-            }
-
-            .chat-messages::-webkit-scrollbar {
-                width: 3px;
-            }
-
-            .chat-messages::-webkit-scrollbar-track {
-                background: transparent;
-            }
-
-            .chat-messages::-webkit-scrollbar-thumb {
-                background: var(--border);
-                border-radius: 2px;
-            }
-
-            .message {
-                margin-bottom: 2rem;
-                opacity: 0;
-                animation: messageSlide 0.4s cubic-bezier(0.2, 0, 0.2, 1) forwards;
-            }
-
-            @keyframes messageSlide {
-                from { 
-                    opacity: 0; 
-                    transform: translateY(20px) scale(0.98); 
-                }
-                to { 
-                    opacity: 1; 
-                    transform: translateY(0) scale(1); 
-                }
-            }
-
-            .message.user {
-                text-align: right;
-            }
-
-            .message.assistant {
-                text-align: left;
-            }
-
-            .message-content {
-                display: inline-block;
-                max-width: 75%;
-                padding: 1.25rem 1.5rem;
-                border-radius: 24px;
-                font-size: 0.95rem;
-                line-height: 1.6;
-                position: relative;
-            }
-
-            .message.user .message-content {
-                background: linear-gradient(135deg, var(--primary), var(--primary-dark));
-                color: #ffffff;
-                border-bottom-right-radius: 8px;
-                box-shadow: 0 4px 12px rgba(0, 102, 255, 0.2);
-            }
-
-            .message.assistant .message-content {
-                background: var(--surface-elevated);
-                color: var(--text);
-                border-bottom-left-radius: 8px;
-                border: 1px solid var(--border);
-            }
-
-            .message-meta {
-                font-size: 0.75rem;
-                color: var(--text-muted);
-                margin-top: 0.5rem;
-                font-weight: 500;
-            }
-
-            .sources {
-                margin-top: 1rem;
-                padding-top: 1rem;
-                border-top: 1px solid var(--border);
-                font-size: 0.8rem;
-                color: var(--text-secondary);
-            }
-
-            .sources span {
-                display: inline-block;
-                background: rgba(0, 102, 255, 0.1);
-                border: 1px solid rgba(0, 102, 255, 0.2);
-                padding: 0.25rem 0.75rem;
-                border-radius: 6px;
-                margin: 0.25rem 0.5rem 0.25rem 0;
-                font-weight: 500;
-                font-size: 0.75rem;
-            }
-
-            .input-area {
-                padding: 2rem;
-                background: linear-gradient(180deg, var(--surface), var(--surface-elevated));
-                border-top: 1px solid var(--border);
-            }
-
-            .input-container {
-                display: flex;
-                gap: 1rem;
-                align-items: stretch;
-            }
-
-            .input-field {
-                flex: 1;
-                padding: 1rem 1.5rem;
-                background: var(--background);
-                border: 2px solid var(--border);
-                border-radius: 28px;
-                color: var(--text);
-                font-size: 0.95rem;
-                outline: none;
-                transition: all 0.2s cubic-bezier(0.2, 0, 0.2, 1);
-                font-weight: 400;
-            }
-
-            .input-field:focus {
-                border-color: var(--primary);
-                box-shadow: 0 0 0 4px var(--border-focus);
-                background: var(--surface);
-            }
-
-            .input-field::placeholder {
-                color: var(--text-muted);
-                font-weight: 400;
-            }
-
-            .send-button {
-                padding: 1rem 2rem;
-                background: linear-gradient(135deg, var(--primary), var(--primary-dark));
-                color: #ffffff;
-                border: none;
-                border-radius: 28px;
-                font-weight: 600;
-                cursor: pointer;
-                transition: all 0.2s cubic-bezier(0.2, 0, 0.2, 1);
-                font-size: 0.95rem;
-                box-shadow: 0 4px 12px rgba(0, 102, 255, 0.2);
-            }
-
-            .send-button:hover:not(:disabled) {
-                transform: translateY(-2px);
-                box-shadow: 0 8px 24px rgba(0, 102, 255, 0.3);
-            }
-
-            .send-button:active {
-                transform: translateY(0);
-            }
-
-            .send-button:disabled {
-                opacity: 0.6;
-                cursor: not-allowed;
-                transform: none;
-                box-shadow: 0 4px 12px rgba(0, 102, 255, 0.1);
-            }
-
-            .examples {
-                display: grid;
-                grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
-                gap: 1rem;
-                margin-top: 1rem;
-            }
-
-            .example {
-                background: linear-gradient(135deg, var(--surface), var(--surface-elevated));
-                border: 1px solid var(--border);
-                border-radius: 12px;
-                padding: 1.5rem;
-                cursor: pointer;
-                transition: all 0.3s cubic-bezier(0.2, 0, 0.2, 1);
-                position: relative;
-                overflow: hidden;
-            }
-
-            .example::before {
-                content: '';
-                position: absolute;
-                top: 0;
-                left: -100%;
-                width: 100%;
-                height: 100%;
-                background: linear-gradient(90deg, transparent, rgba(0, 102, 255, 0.05), transparent);
-                transition: left 0.5s ease;
-            }
-
-            .example:hover::before {
-                left: 100%;
-            }
-
-            .example:hover {
-                border-color: var(--primary);
-                transform: translateY(-4px);
-                box-shadow: 0 12px 32px rgba(0, 0, 0, 0.2);
-                background: linear-gradient(135deg, var(--surface-elevated), var(--surface));
-            }
-
-            .example-title {
-                font-weight: 600;
-                color: var(--text);
-                margin-bottom: 0.5rem;
-                font-size: 0.95rem;
-            }
-
-            .example-desc {
-                font-size: 0.85rem;
-                color: var(--text-secondary);
-                font-weight: 400;
-            }
-
-            .loading {
-                display: inline-flex;
-                align-items: center;
-                gap: 0.5rem;
-                color: var(--text-secondary);
-                font-weight: 500;
-            }
-
-            .loading::after {
-                content: '';
-                width: 14px;
-                height: 14px;
-                border: 2px solid currentColor;
-                border-top-color: transparent;
-                border-radius: 50%;
-                animation: spin 1s linear infinite;
-            }
-
-            @keyframes spin {
-                to { transform: rotate(360deg); }
-            }
-
-            .visualization-container {
-                margin: 1.5rem 0;
-                background: var(--surface-elevated);
-                border-radius: 12px;
-                padding: 1.5rem;
-                border: 1px solid var(--border);
-            }
-
-            .welcome {
-                text-align: center;
-                padding: 4rem 2rem;
-                color: var(--text-secondary);
-            }
-
-            .welcome h3 {
-                font-size: 1.25rem;
-                font-weight: 600;
-                margin-bottom: 0.5rem;
-                color: var(--text);
-            }
-
-            .welcome p {
-                font-size: 0.95rem;
-                font-weight: 400;
-            }
-
-            @media (max-width: 768px) {
-                .container {
-                    padding: 1rem;
-                }
-                
-                .header h1 {
-                    font-size: 1.75rem;
-                }
-                
-                .chat-messages {
-                    height: 400px;
-                    padding: 1.5rem;
-                }
-                
-                .message-content {
-                    max-width: 85%;
-                    padding: 1rem 1.25rem;
-                }
-                
-                .input-area {
-                    padding: 1.5rem;
-                }
-                
-                .input-container {
-                    flex-direction: column;
-                    gap: 0.75rem;
-                }
-                
-                .send-button {
-                    align-self: stretch;
-                }
-                
-                .examples {
-                    grid-template-columns: 1fr;
-                }
-            }
-        </style>
-    </head>
-    <body>
-        <div class="container">
-            <div class="header">
-                <h1><span class="brand">Web3</span> Research Co-Pilot</h1>
-                <p>Professional cryptocurrency analysis and market intelligence</p>
-            </div>
-
-            <div id="status" class="status checking">
-                <span>Initializing research systems...</span>
-            </div>
-
-            <div class="chat-interface">
-                <div id="chatMessages" class="chat-messages">
-                    <div class="welcome">
-                        <h3>Welcome to Web3 Research Co-Pilot</h3>
-                        <p>Ask about market trends, DeFi protocols, or blockchain analytics</p>
-                    </div>
-                </div>
-                <div class="input-area">
-                    <div class="input-container">
-                        <input 
-                            type="text" 
-                            id="queryInput" 
-                            class="input-field"
-                            placeholder="Research Bitcoin trends, analyze DeFi yields, compare protocols..."
-                            maxlength="500"
-                        >
-                        <button id="sendBtn" class="send-button">Research</button>
-                    </div>
-                </div>
-            </div>
-
-            <div class="examples">
-                <div class="example" onclick="setQuery('Analyze Bitcoin price trends and institutional adoption patterns')">
-                    <div class="example-title">Market Analysis</div>
-                    <div class="example-desc">Bitcoin trends, institutional flows, and market sentiment</div>
-                </div>
-                <div class="example" onclick="setQuery('Compare top DeFi protocols by TVL, yield, and risk metrics')">
-                    <div class="example-title">DeFi Intelligence</div>
-                    <div class="example-desc">Protocol comparison, yield analysis, and risk assessment</div>
-                </div>
-                <div class="example" onclick="setQuery('Evaluate Ethereum Layer 2 scaling solutions and adoption metrics')">
-                    <div class="example-title">Layer 2 Research</div>
-                    <div class="example-desc">Scaling solutions, transaction costs, and ecosystem growth</div>
-                </div>
-                <div class="example" onclick="setQuery('Identify optimal yield farming strategies across multiple chains')">
-                    <div class="example-title">Yield Optimization</div>
-                    <div class="example-desc">Cross-chain opportunities, APY tracking, and risk analysis</div>
-                </div>
-            </div>
-        </div>
-
-        <script>
-            let chatHistory = [];
-            let messageCount = 0;
-
-            async function checkStatus() {
-                try {
-                    const response = await fetch('/status');
-                    const status = await response.json();
+    
+    async def _extract_chart_data_from_response(self, response: str) -> Optional[Dict[str, Any]]:
+        """Extract chart data JSON from agent response"""
+        try:
+            import re
+            import json
+            
+            logger.info(f"🔍 Checking response for chart data (length: {len(response)} chars)")
+            
+            # Look for JSON objects containing chart_type - find opening brace and matching closing brace
+            chart_data_found = None
+            lines = response.split('\n')
+            
+            for i, line in enumerate(lines):
+                if '"chart_type"' in line and line.strip().startswith('{'):
+                    # Found potential start of chart JSON
+                    json_start = i
+                    brace_count = 0
+                    json_lines = []
                     
-                    const statusDiv = document.getElementById('status');
+                    for j in range(i, len(lines)):
+                        current_line = lines[j]
+                        json_lines.append(current_line)
+                        
+                        # Count braces to find matching close
+                        brace_count += current_line.count('{') - current_line.count('}')
+                        
+                        if brace_count == 0:
+                            # Found complete JSON object
+                            json_text = '\n'.join(json_lines)
+                            try:
+                                chart_data = json.loads(json_text.strip())
+                                if chart_data.get("chart_type") and chart_data.get("chart_type") != "error":
+                                    logger.info(f"✅ Found valid chart data: {chart_data.get('chart_type')}")
+                                    return chart_data
+                            except json.JSONDecodeError:
+                                # Try without newlines
+                                try:
+                                    json_text_clean = json_text.replace('\n', '').replace('  ', ' ')
+                                    chart_data = json.loads(json_text_clean)
+                                    if chart_data.get("chart_type") and chart_data.get("chart_type") != "error":
+                                        logger.info(f"✅ Found valid chart data (cleaned): {chart_data.get('chart_type')}")
+                                        return chart_data
+                                except json.JSONDecodeError:
+                                    continue
+                            break
+            
+            # Fallback to original regex approach for single-line JSON
+            json_pattern = r'\{[^{}]*"chart_type"[^{}]*\}|\{(?:[^{}]|\{[^{}]*\})*"chart_type"(?:[^{}]|\{[^{}]*\})*\}'
+            matches = re.findall(json_pattern, response, re.DOTALL)
+            
+            logger.info(f"   Found {len(matches)} potential chart data objects")
+            
+            for match in matches:
+                try:
+                    # Clean up the JSON
+                    cleaned_match = match.replace('\\"', '"').replace('\\n', '\n')
+                    chart_data = json.loads(cleaned_match)
                     
-                    if (status.enabled && status.gemini_configured) {
-                        statusDiv.className = 'status online';
-                        statusDiv.innerHTML = `
-                            <span>Research systems online</span>
-                            <div style="margin-top: 0.5rem; font-size: 0.85rem; opacity: 0.8;">
-                                Tools: ${status.tools_available.join(' • ')}
-                            </div>
-                        `;
-                    } else {
-                        statusDiv.className = 'status offline';
-                        statusDiv.innerHTML = `
-                            <span>Limited mode - Configure GEMINI_API_KEY for full functionality</span>
-                            <div style="margin-top: 0.5rem; font-size: 0.85rem; opacity: 0.8;">
-                                Available: ${status.tools_available.join(' • ')}
-                            </div>
-                        `;
-                    }
-                } catch (error) {
-                    const statusDiv = document.getElementById('status');
-                    statusDiv.className = 'status offline';
-                    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) return;
-
-                addMessage('user', query);
-                input.value = '';
-
-                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();
-
-                    if (result.success) {
-                        addMessage('assistant', result.response, result.sources, result.visualizations);
-                    } else {
-                        addMessage('assistant', result.response || 'Analysis failed. Please try again.');
-                    }
-                } catch (error) {
-                    addMessage('assistant', 'Connection error. Please check your network and try again.');
-                } finally {
-                    sendBtn.disabled = false;
-                    sendBtn.innerHTML = 'Research';
-                    input.focus();
-                }
-            }
-
-            function addMessage(sender, content, sources = [], visualizations = []) {
-                const messagesDiv = document.getElementById('chatMessages');
+                    if chart_data.get("chart_type") and chart_data.get("chart_type") != "error":
+                        logger.info(f"✅ Valid chart data found: {chart_data.get('chart_type')}")
+                        return chart_data
+                        
+                except json.JSONDecodeError:
+                    continue
+                    
+            logger.info("⚠️ No valid chart data found in response")
+            return None
+            
+        except Exception as e:
+            logger.error(f"Chart data extraction error: {e}")
+            return None
+    
+    async def _generate_chart_from_data(self, chart_data: Dict[str, Any]) -> Optional[str]:
+        """Generate HTML visualization from chart data"""
+        try:
+            if not self.viz:
+                logger.warning("Visualization tools not available")
+                return None
                 
-                // Clear welcome message
-                if (messageCount === 0) {
-                    messagesDiv.innerHTML = '';
-                }
-                messageCount++;
-
-                const messageDiv = document.createElement('div');
-                messageDiv.className = `message ${sender}`;
-
-                let sourcesHtml = '';
-                if (sources && sources.length > 0) {
-                    sourcesHtml = `
-                        <div class="sources">
-                            Sources: ${sources.map(s => `<span>${s}</span>`).join('')}
-                        </div>
-                    `;
-                }
-
-                let visualizationHtml = '';
-                if (visualizations && visualizations.length > 0) {
-                    visualizationHtml = visualizations.map(viz => 
-                        `<div class="visualization-container">${viz}</div>`
-                    ).join('');
-                }
-
-                messageDiv.innerHTML = `
-                    <div class="message-content">
-                        ${content.replace(/\n/g, '<br>')}
-                        ${sourcesHtml}
-                    </div>
-                    ${visualizationHtml}
-                    <div class="message-meta">${new Date().toLocaleTimeString()}</div>
-                `;
-
-                messagesDiv.appendChild(messageDiv);
-                messagesDiv.scrollTop = messagesDiv.scrollHeight;
-
-                chatHistory.push({ role: sender, content });
-                if (chatHistory.length > 20) chatHistory = chatHistory.slice(-20);
-            }
-
-            function setQuery(query) {
-                document.getElementById('queryInput').value = query;
-                setTimeout(() => sendQuery(), 100);
-            }
-
-            // Event listeners
-            document.getElementById('queryInput').addEventListener('keypress', (e) => {
-                if (e.key === 'Enter') sendQuery();
-            });
+            chart_type = chart_data.get("chart_type")
+            data = chart_data.get("data", {})
+            config = chart_data.get("config", {})
+            
+            logger.info(f"Generating {chart_type} chart with data keys: {list(data.keys())}")
+            
+            if chart_type == "price_chart":
+                fig = self.viz.create_price_chart(data, data.get("symbol", "BTC"))
+            elif chart_type == "market_overview":
+                fig = self.viz.create_market_overview(data.get("coins", []))
+            elif chart_type == "defi_tvl":
+                fig = self.viz.create_defi_tvl_chart(data.get("protocols", []))
+            elif chart_type == "portfolio_pie":
+                # Convert allocation data to the expected format
+                allocations = {item["name"]: item["value"] for item in data.get("allocations", [])}
+                fig = self.viz.create_portfolio_pie_chart(allocations)
+            elif chart_type == "gas_tracker":
+                fig = self.viz.create_gas_tracker(data)
+            else:
+                logger.warning(f"Unknown chart type: {chart_type}")
+                return None
+                
+            # Convert to HTML - use div_id and config for embedding
+            chart_id = f'chart_{chart_type}_{int(time.time())}'
+            
+            # Generate HTML with inline Plotly for reliable rendering
+            html = fig.to_html(
+                include_plotlyjs='inline',  # Embed Plotly directly - no CDN issues
+                div_id=chart_id,
+                config={'responsive': True, 'displayModeBar': False}
+            )
+            
+            # With inline Plotly, we need to extract the body content only
+            import re
+            # Extract everything between <body> and </body>
+            body_match = re.search(r'<body[^>]*>(.*?)</body>', html, re.DOTALL)
+            if body_match:
+                chart_html = body_match.group(1).strip()
+                logger.info(f"✅ Chart HTML generated ({len(chart_html)} chars) - inline format")
+                return chart_html
+            else:
+                # Fallback - return the full HTML minus the html/head/body tags
+                # Remove full document structure, keep only the content
+                cleaned_html = re.sub(r'<html[^>]*>.*?<body[^>]*>', '', html, flags=re.DOTALL)
+                cleaned_html = re.sub(r'</body>.*?</html>', '', cleaned_html, flags=re.DOTALL)
+                logger.info(f"✅ Chart HTML generated ({len(cleaned_html)} chars) - cleaned format")
+                return cleaned_html.strip()
+            
+        except Exception as e:
+            logger.error(f"Chart generation error: {e}")
+            return None
+    def _clean_agent_response(self, response: str) -> str:
+        """Clean agent response by removing JSON data blocks"""
+        try:
+            import re
+            
+            # Method 1: Remove complete JSON objects with balanced braces that contain chart_type
+            lines = response.split('\n')
+            cleaned_lines = []
+            skip_mode = False
+            brace_count = 0
+            
+            for line in lines:
+                if not skip_mode:
+                    if '"chart_type"' in line and line.strip().startswith('{'):
+                        # Found start of chart JSON - start skipping
+                        skip_mode = True
+                        brace_count = line.count('{') - line.count('}')
+                        if brace_count == 0:
+                            # Single line JSON, skip this line
+                            skip_mode = False
+                        continue
+                    else:
+                        cleaned_lines.append(line)
+                else:
+                    # In skip mode - count braces to find end
+                    brace_count += line.count('{') - line.count('}')
+                    if brace_count <= 0:
+                        # Found end of JSON block
+                        skip_mode = False
+                    # Skip this line in any case
+            
+            cleaned = '\n'.join(cleaned_lines)
+            
+            # Method 2: Fallback regex for any remaining JSON patterns
+            json_patterns = [
+                r'\{[^{}]*"chart_type"[^{}]*\}',  # Simple single-line JSON
+                r'```json\s*\{.*?"chart_type".*?\}\s*```',  # Markdown JSON blocks
+            ]
+            
+            for pattern in json_patterns:
+                cleaned = re.sub(pattern, '', cleaned, flags=re.DOTALL)
+            
+            # Clean up extra whitespace
+            cleaned = re.sub(r'\n\s*\n\s*\n+', '\n\n', cleaned)
+            cleaned = cleaned.strip()
+            
+            return cleaned
+            
+        except Exception as e:
+            logger.error(f"Response cleaning error: {e}")
+            return response
 
-            document.getElementById('sendBtn').addEventListener('click', sendQuery);
+# Initialize service
+service = Web3CoPilotService()
 
-            // Initialize
-            document.addEventListener('DOMContentLoaded', () => {
-                checkStatus();
-                document.getElementById('queryInput').focus();
-            });
-        </script>
-    </body>
-    </html>
-    """
-    return HTMLResponse(content=html_content)
 
+@app.get("/", response_class=HTMLResponse)
+async def get_homepage(request: Request):
+    """Serve the main interface using templates"""
+    return templates.TemplateResponse("index.html", {"request": request})
 @app.get("/status")
 async def get_status():
     """System status endpoint"""
@@ -790,8 +408,147 @@ async def get_status():
 
 @app.post("/query", response_model=QueryResponse)
 async def process_query(request: QueryRequest):
-    """Process research query"""
-    return await service.process_query(request.query)
+    """Process research query with sanitized logging"""
+    # Log incoming request without exposing sensitive data
+    query_preview = request.query[:50] + "..." if len(request.query) > 50 else request.query
+    logger.info(f"Query received: {query_preview}")
+    
+    start_time = datetime.now()
+    
+    try:
+        # Process the query
+        result = await service.process_query(request.query)
+        
+        # Log result without sensitive details
+        processing_time = (datetime.now() - start_time).total_seconds()
+        logger.info(f"Query processed in {processing_time:.2f}s - Success: {result.success}")
+        
+        if result.success:
+            logger.info(f"Response generated: {len(result.response)} characters")
+        else:
+            logger.info("Query processing failed")
+        
+        return result
+        
+    except Exception as e:
+        processing_time = (datetime.now() - start_time).total_seconds()
+        logger.error(f"Query processing error after {processing_time:.2f}s")
+        
+        return QueryResponse(
+            success=False,
+            response="We're experiencing technical difficulties. Please try again in a moment.",
+            error="System temporarily unavailable"
+        )
+
+@app.post("/query/stream")
+async def process_query_stream(request: QueryRequest):
+    """Process research query with real-time progress updates"""
+    query_preview = request.query[:50] + "..." if len(request.query) > 50 else request.query
+    logger.info(f"Streaming query received: {query_preview}")
+    
+    async def generate_progress():
+        try:
+            # Send initial status
+            yield f"data: {json.dumps({'type': 'status', 'message': 'Initializing research...', 'progress': 10})}\n\n"
+            await asyncio.sleep(0.1)
+            
+            # Send tool selection status
+            yield f"data: {json.dumps({'type': 'status', 'message': 'Analyzing query and selecting tools...', 'progress': 20})}\n\n"
+            await asyncio.sleep(0.5)
+            
+            # Send tools status
+            if service.agent and service.agent.enabled:
+                tools = [tool.name for tool in service.agent.tools]
+                yield f"data: {json.dumps({'type': 'tools', 'message': f'Available tools: {tools}', 'progress': 30})}\n\n"
+                await asyncio.sleep(0.5)
+            
+            # Send processing status
+            yield f"data: {json.dumps({'type': 'status', 'message': 'Executing tools and gathering data...', 'progress': 50})}\n\n"
+            await asyncio.sleep(0.5)
+            
+            # Send Ollama/Gemini processing status with heartbeats
+            llm_name = "Gemini" if request.use_gemini else "Ollama"
+            yield f"data: {json.dumps({'type': 'status', 'message': f'{llm_name} is analyzing data and generating response...', 'progress': 70})}\n\n"
+            await asyncio.sleep(1.0)
+            
+            # Send additional heartbeat messages during processing
+            yield f"data: {json.dumps({'type': 'status', 'message': f'{llm_name} is thinking deeply about your query...', 'progress': 75})}\n\n"
+            await asyncio.sleep(2.0)
+            
+            yield f"data: {json.dumps({'type': 'status', 'message': f'Still processing... {llm_name} generates detailed responses', 'progress': 80})}\n\n"
+            await asyncio.sleep(3.0)
+            
+            # Process the actual query with timeout and periodic heartbeats
+            start_time = datetime.now()
+            
+            # Create a task for the query processing
+            query_task = asyncio.create_task(service.process_query(request.query, request.use_gemini))
+            
+            try:
+                # Send periodic heartbeats while waiting for Ollama
+                heartbeat_count = 0
+                while not query_task.done():
+                    try:
+                        # Wait for either completion or timeout
+                        result = await asyncio.wait_for(asyncio.shield(query_task), timeout=10.0)
+                        break  # Query completed
+                    except asyncio.TimeoutError:
+                        # Send heartbeat every 10 seconds
+                        heartbeat_count += 1
+                        elapsed = (datetime.now() - start_time).total_seconds()
+                        
+                        if elapsed > 300:  # 5 minute hard timeout
+                            query_task.cancel()
+                            raise asyncio.TimeoutError("Hard timeout reached")
+                        
+                        progress = min(85 + (heartbeat_count * 2), 95)  # Progress slowly from 85 to 95
+                        llm_name = "Gemini" if request.use_gemini else "Ollama"
+                        yield f"data: {json.dumps({'type': 'status', 'message': f'{llm_name} is still working... ({elapsed:.0f}s elapsed)', 'progress': progress})}\n\n"
+                        
+                # If we get here, the query completed successfully
+                result = query_task.result()
+                processing_time = (datetime.now() - start_time).total_seconds()
+                
+                # Send completion status
+                yield f"data: {json.dumps({'type': 'status', 'message': f'Analysis complete ({processing_time:.1f}s)', 'progress': 90})}\n\n"
+                await asyncio.sleep(0.5)
+                
+                # Send final result
+                yield f"data: {json.dumps({'type': 'result', 'data': result.model_dump(), 'progress': 100})}\n\n"
+                
+            except asyncio.TimeoutError:
+                processing_time = (datetime.now() - start_time).total_seconds()
+                logger.error(f"Query processing timed out after {processing_time:.1f}s")
+                
+                # Send timeout result with available data
+                yield f"data: {json.dumps({'type': 'result', 'data': {'success': False, 'response': 'Analysis timed out, but tools successfully gathered data. The system collected cryptocurrency prices, DeFi protocol information, and blockchain data. Please try a simpler query or try again.', 'sources': [], 'metadata': {'timeout': True, 'processing_time': processing_time}, 'visualizations': [], 'error': 'Processing timeout'}, 'progress': 100})}\n\n"
+                
+            except Exception as query_error:
+                processing_time = (datetime.now() - start_time).total_seconds()
+                logger.error(f"Query processing failed: {query_error}")
+                
+                # Send error result
+                yield f"data: {json.dumps({'type': 'result', 'data': {'success': False, 'response': f'Analysis failed: {str(query_error)}. The system was able to gather some data but encountered an error during final processing.', 'sources': [], 'metadata': {'error': True, 'processing_time': processing_time}, 'visualizations': [], 'error': str(query_error)}, 'progress': 100})}\n\n"
+            
+            # Send completion signal
+            yield f"data: {json.dumps({'type': 'complete'})}\n\n"
+            
+        except Exception as e:
+            logger.error(f"Streaming error: {e}")
+            yield f"data: {json.dumps({'type': 'error', 'message': str(e)})}\n\n"
+    
+    return StreamingResponse(
+        generate_progress(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "Content-Type": "text/event-stream",
+            "X-Accel-Buffering": "no",  # Disable buffering for nginx
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Headers": "Content-Type",
+        }
+    )
 
 @app.get("/health")
 async def health_check():
@@ -803,6 +560,54 @@ async def health_check():
         "version": "2.0.0"
     }
 
+@app.get("/debug/tools")
+async def debug_tools():
+    """Debug endpoint to test tool availability and functionality"""
+    try:
+        if not service.enabled or not service.agent:
+            return {
+                "success": False,
+                "error": "AI agent not enabled",
+                "tools_available": False,
+                "gemini_configured": bool(config.GEMINI_API_KEY)
+            }
+        
+        tools_info = []
+        for tool in service.agent.tools:
+            tools_info.append({
+                "name": tool.name,
+                "description": getattr(tool, 'description', 'No description'),
+                "enabled": getattr(tool, 'enabled', True)
+            })
+        
+        # Test a simple API call
+        test_result = None
+        try:
+            test_result = await service.process_query("What is the current Bitcoin price?")
+        except Exception as e:
+            test_result = {"error": str(e)}
+        
+        return {
+            "success": True,
+            "tools_count": len(service.agent.tools),
+            "tools_info": tools_info,
+            "test_query_result": {
+                "success": test_result.success if hasattr(test_result, 'success') else False,
+                "response_length": len(test_result.response) if hasattr(test_result, 'response') else 0,
+                "sources": test_result.sources if hasattr(test_result, 'sources') else [],
+                "error": test_result.error if hasattr(test_result, 'error') else None
+            },
+            "gemini_configured": bool(config.GEMINI_API_KEY),
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as e:
+        logger.error(f"Debug tools error: {e}")
+        return {
+            "success": False,
+            "error": str(e),
+            "timestamp": datetime.now().isoformat()
+        }
+
 if __name__ == "__main__":
     import uvicorn
     logger.info("Starting Web3 Research Co-Pilot...")

app_config.yaml

@@ -0,0 +1,19 @@
+title: Web3 Research Co-Pilot
+emoji: 🚀
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_file: app.py
+dockerfile: Dockerfile
+license: mit
+tags:
+- cryptocurrency
+- blockchain
+- defi
+- ai-research
+- ollama
+- llama3
+pinned: false
+header: default
+short_description: AI-powered cryptocurrency research assistant with real-time data
+suggested_hardware: t4-medium

debug_gemini.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""
+Debug test to understand why Gemini responses aren't being cleaned
+"""
+
+import asyncio
+import sys
+import os
+
+# Add src to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+from langchain_google_genai import ChatGoogleGenerativeAI
+from src.utils.config import config
+
+async def test_gemini_response_structure():
+    """Test the structure of Gemini responses to understand the cleaning issue"""
+    
+    if not config.GEMINI_API_KEY:
+        print("❌ No Gemini API key available")
+        return False
+    
+    try:
+        print("🧪 Testing Gemini response structure...")
+        
+        # Initialize Gemini
+        llm = ChatGoogleGenerativeAI(
+            model="gemini-2.0-flash-lite",
+            google_api_key=config.GEMINI_API_KEY,
+            temperature=0.1
+        )
+        
+        # Test simple query
+        response = await llm.ainvoke("What is 2+2?")
+        
+        print(f"📄 Response type: {type(response)}")
+        print(f"📄 Response dir: {[attr for attr in dir(response) if not attr.startswith('_')]}")
+        
+        if hasattr(response, 'content'):
+            print(f"✅ Response has 'content' attribute")
+            print(f"📝 Content: {response.content}")
+            print(f"📝 Content type: {type(response.content)}")
+        else:
+            print("❌ Response does NOT have 'content' attribute")
+            
+        print(f"📄 Full response: {str(response)}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Test failed: {e}")
+        return False
+
+async def main():
+    success = await test_gemini_response_structure()
+    if success:
+        print("\n🎉 Test completed!")
+        return 0
+    else:
+        print("\n❌ Test failed!")
+        return 1
+
+if __name__ == "__main__":
+    exit_code = asyncio.run(main())
+    sys.exit(exit_code)

dev_check.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+# Development syntax checker script
+
+echo "🔍 Running development syntax check..."
+
+# Check Python syntax using built-in compile
+echo "1️⃣ Python syntax validation..."
+find . -name "*.py" -not -path "./__pycache__/*" -not -path "./.*" | while read file; do
+    python -m py_compile "$file" 2>/dev/null
+    if [ $? -eq 0 ]; then
+        echo "  ✅ $file"
+    else
+        echo "  ❌ $file - SYNTAX ERROR"
+        python -m py_compile "$file"
+        exit 1
+    fi
+done
+
+echo ""
+echo "2️⃣ Running comprehensive validation..."
+python validate_startup.py
+
+echo ""
+echo "3️⃣ Quick import test..."
+python -c "
+try:
+    import app
+    print('  ✅ app.py imports successfully')
+except Exception as e:
+    print(f'  ❌ app.py import failed: {e}')
+    exit(1)
+
+try:
+    from src.agent.research_agent import Web3ResearchAgent
+    print('  ✅ research_agent.py imports successfully')
+except Exception as e:
+    print(f'  ❌ research_agent.py import failed: {e}')
+    exit(1)
+"
+
+if [ $? -eq 0 ]; then
+    echo ""
+    echo "🎉 All syntax checks passed! Ready for deployment."
+else
+    echo ""
+    echo "❌ Syntax check failed. Please fix errors before deploying."
+    exit 1
+fi

src/agent/research_agent.py

@@ -1,6 +1,5 @@
-from langchain.agents import AgentExecutor, create_tool_calling_agent
 from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_community.llms import Ollama
 from langchain.memory import ConversationBufferWindowMemory
 from typing import List, Dict, Any
 import asyncio
@@ -8,65 +7,110 @@ from datetime import datetime
 
 from src.tools.coingecko_tool import CoinGeckoTool
 from src.tools.defillama_tool import DeFiLlamaTool
+from src.tools.cryptocompare_tool import CryptoCompareTool
 from src.tools.etherscan_tool import EtherscanTool
-from src.agent.query_planner import QueryPlanner
+from src.tools.chart_data_tool import ChartDataTool
+from src.agent.memory_manager import MemoryManager
 from src.utils.config import config
 from src.utils.logger import get_logger
+from src.utils.ai_safety import ai_safety
 
 logger = get_logger(__name__)
 
+# Add version logging for debugging
+try:
+    from version import VERSION
+    logger.info(f"🔧 Research Agent Version: {VERSION}")
+except ImportError:
+    logger.info("🔧 Research Agent Version: Unknown")
+
 class Web3ResearchAgent:
     def __init__(self):
         self.llm = None
+        self.fallback_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
+        self.gemini_available = False
+        self.memory_manager = MemoryManager(window_size=10)
         
         try:
-            self.llm = ChatGoogleGenerativeAI(
-                model="gemini-1.5-flash",
-                google_api_key=config.GEMINI_API_KEY,
-                temperature=0.1,
-                max_tokens=2048
-            )
+            # Always initialize Ollama
+            logger.info("🔧 Initializing Ollama as fallback")
+            self._init_ollama()
             
+            # Try to initialize Gemini if API key is available
+            if config.GEMINI_API_KEY:
+                logger.info("🔧 Initializing Gemini as primary option")
+                self._init_gemini()
+                
             self.tools = self._initialize_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.executor = AgentExecutor(
-                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")
-            
+            logger.info("🧠 Memory Manager initialized with conversation tracking")
+                
         except Exception as e:
-            logger.error(f"Agent init failed: {e}")
+            logger.error(f"Agent initialization failed: {e}")
             self.enabled = False
+
+    def _init_ollama(self):
+        """Initialize Ollama LLM with optimized settings"""
+        try:
+            self.fallback_llm = Ollama(
+                model=config.OLLAMA_MODEL,
+                base_url=config.OLLAMA_BASE_URL,
+                temperature=0.1
+            )
+            logger.info(f"✅ Ollama initialized - Model: {config.OLLAMA_MODEL} (timeout optimized)")
+        except Exception as e:
+            logger.error(f"Ollama initialization failed: {e}")
+            raise
     
+    def _init_gemini(self):
+        """Initialize Gemini LLM"""
+        try:
+            self.llm = ChatGoogleGenerativeAI(
+                model="gemini-2.0-flash-lite",  # Updated to Gemini 2.0 Flash-Lite
+                google_api_key=config.GEMINI_API_KEY,
+                temperature=0.1
+            )
+            self.gemini_available = True
+            logger.info("✅ Gemini initialized with gemini-2.0-flash-lite")
+        except Exception as e:
+            logger.warning(f"Gemini initialization failed: {e}")
+            self.gemini_available = False
+
+    def _init_ollama_only(self):
+        """Initialize with only Ollama LLM (deprecated - kept for compatibility)"""
+        self._init_ollama()
+
+    def _init_with_gemini_fallback(self):
+        """Initialize with Gemini primary and Ollama fallback (deprecated - kept for compatibility)"""
+        self._init_ollama()
+        self._init_gemini()
+
     def _initialize_tools(self):
         tools = []
         
-        try:
-            tools.append(CoinGeckoTool())
-            logger.info("CoinGecko tool initialized")
-        except Exception as e:
-            logger.warning(f"CoinGecko tool failed: {e}")
+        # Skip CoinGecko if no API key available
+        if config.COINGECKO_API_KEY:
+            try:
+                tools.append(CoinGeckoTool())
+                logger.info("CoinGecko tool initialized")
+            except Exception as e:
+                logger.warning(f"CoinGecko tool failed: {e}")
+        else:
+            logger.info("CoinGecko tool skipped - no API key available")
         
         try:
             tools.append(DeFiLlamaTool())
             logger.info("DeFiLlama tool initialized")
         except Exception as e:
             logger.warning(f"DeFiLlama tool failed: {e}")
+
+        try:
+            tools.append(CryptoCompareTool())
+            logger.info("CryptoCompare tool initialized")
+        except Exception as e:
+            logger.warning(f"CryptoCompare tool failed: {e}")
         
         try:
             tools.append(EtherscanTool())
@@ -74,110 +118,577 @@ class Web3ResearchAgent:
         except Exception as e:
             logger.warning(f"Etherscan tool failed: {e}")
         
+        try:
+            tools.append(ChartDataTool())
+            logger.info("ChartDataTool initialized")
+        except Exception as e:
+            logger.warning(f"ChartDataTool failed: {e}")
+        
         return tools
-    
-    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")
-        ])
+
+    async def research_query(self, query: str, use_gemini: bool = False) -> Dict[str, Any]:
+        """Research query with dynamic LLM selection - Enhanced with AI Safety"""
+        
+        # AI Safety Check 1: Sanitize and validate input
+        sanitized_query, is_safe, safety_reason = ai_safety.sanitize_query(query)
+        if not is_safe:
+            ai_safety.log_safety_event("blocked_query", {
+                "original_query": query[:100],
+                "reason": safety_reason,
+                "timestamp": datetime.now().isoformat()
+            })
+            return {
+                "success": False,
+                "query": query,
+                "error": f"Safety filter: {safety_reason}",
+                "result": "Your query was blocked by our safety filters. Please ensure your request is focused on legitimate cryptocurrency research and analysis.",
+                "sources": [],
+                "metadata": {"timestamp": datetime.now().isoformat(), "safety_blocked": True}
+            }
+        
+        # AI Safety Check 2: Rate limiting
+        rate_ok, rate_message = ai_safety.check_rate_limit()
+        if not rate_ok:
+            ai_safety.log_safety_event("rate_limit", {
+                "message": rate_message,
+                "timestamp": datetime.now().isoformat()
+            })
+            return {
+                "success": False,
+                "query": query,
+                "error": "Rate limit exceeded",
+                "result": f"Please wait before making another request. {rate_message}",
+                "sources": [],
+                "metadata": {"timestamp": datetime.now().isoformat(), "rate_limited": True}
+            }
         
-        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",
+                "error": "Research agent not initialized",
+                "result": "Research service not available. Please check configuration.",
                 "sources": [],
                 "metadata": {"timestamp": datetime.now().isoformat()}
             }
         
+        # Get conversation context from memory
+        memory_context = self.memory_manager.get_relevant_context(sanitized_query)
+        logger.info(f"🧠 Retrieved memory context: {len(memory_context.get('cached_context', []))} relevant items")
+        
+        try:
+            # Choose LLM based on user preference and availability
+            if use_gemini and self.gemini_available:
+                logger.info("🤖 Processing with Gemini + Tools (Safety Enhanced + Memory)")
+                result = await self._research_with_gemini_tools(sanitized_query, memory_context)
+            else:
+                logger.info("🤖 Processing with Ollama + Tools (Safety Enhanced + Memory)")
+                result = await self._research_with_ollama_tools(sanitized_query, memory_context)
+                
+            # Save successful interaction to memory
+            if result.get("success"):
+                metadata = {
+                    "llm_used": result.get("metadata", {}).get("llm_used", "unknown"),
+                    "tools_used": result.get("metadata", {}).get("tools_used", []),
+                    "timestamp": datetime.now().isoformat(),
+                    "sources": result.get("sources", [])
+                }
+                self.memory_manager.add_interaction(query, result["result"], metadata)
+                logger.info("🧠 Interaction saved to memory")
+                
+            return result
+                
+        except Exception as e:
+            logger.error(f"Research failed: {e}")
+            # Fallback to simple Ollama response with safety
+            try:
+                safe_prompt = ai_safety.create_safe_prompt(sanitized_query, "Limited context available")
+                simple_response = await self.fallback_llm.ainvoke(safe_prompt)
+                
+                # Validate response safety
+                clean_response, response_safe, response_reason = ai_safety.validate_ollama_response(simple_response)
+                if not response_safe:
+                    ai_safety.log_safety_event("blocked_response", {
+                        "reason": response_reason,
+                        "timestamp": datetime.now().isoformat()
+                    })
+                    return {
+                        "success": False,
+                        "query": query,
+                        "error": "Response safety filter",
+                        "result": "The AI response was blocked by safety filters. Please try a different query.",
+                        "sources": [],
+                        "metadata": {"timestamp": datetime.now().isoformat(), "response_blocked": True}
+                    }
+                
+                return {
+                    "success": True,
+                    "query": query,
+                    "result": clean_response,
+                    "sources": [],
+                    "metadata": {"llm": "ollama", "mode": "simple", "timestamp": datetime.now().isoformat()}
+                }
+            except Exception as fallback_error:
+                logger.error(f"Fallback response failed: {fallback_error}")
+                return {
+                    "success": False,
+                    "query": query,
+                    "error": str(fallback_error),
+                    "result": f"Research failed: {str(fallback_error)}",
+                    "sources": [],
+                    "metadata": {"timestamp": datetime.now().isoformat()}
+                }
+
+    async def _research_with_ollama_tools(self, query: str, memory_context: Dict[str, Any] = None) -> Dict[str, Any]:
+        """Research using Ollama with manual tool calling - Enhanced with memory"""
         try:
-            logger.info(f"Processing: {query}")
+            # Step 1: Analyze query to determine which tools to use
+            # Include memory context in analysis if available
+            context_note = ""
+            if memory_context and memory_context.get("cached_context"):
+                context_note = f"\n\nPrevious context: {len(memory_context['cached_context'])} related queries found"
             
-            research_plan = await self.query_planner.plan_research(query)
+            tool_analysis_prompt = f"""Tools for: "{query}"{context_note}
+
+cryptocompare_data: crypto prices
+etherscan_data: Ethereum data  
+defillama_data: DeFi TVL
+chart_data_provider: charts
+
+Bitcoin price → cryptocompare_data
+DeFi TVL → defillama_data
+Ethereum → etherscan_data
+
+Answer with tool names:"""
+            try:
+                tool_response = await asyncio.wait_for(
+                    self.fallback_llm.ainvoke(tool_analysis_prompt),
+                    timeout=30  # 30 second timeout for tool analysis
+                )
+                logger.info(f"🧠 Ollama tool analysis response: {str(tool_response)[:500]}...")
+                
+                # Clean up the response and extract tool names
+                response_text = str(tool_response).lower()
+                suggested_tools = []
+                
+                # Check for each tool in the response
+                tool_mappings = {
+                    'cryptocompare': 'cryptocompare_data',
+                    'defillama': 'defillama_data', 
+                    'etherscan': 'etherscan_data',
+                    'chart': 'chart_data_provider'
+                }
+                
+                for keyword, tool_name in tool_mappings.items():
+                    if keyword in response_text:
+                        suggested_tools.append(tool_name)
+                
+            except asyncio.TimeoutError:
+                logger.warning("⏱️ Tool analysis timed out, using fallback tool selection")
+                # Fallback tool selection based on query keywords
+                suggested_tools = []
+                query_lower = query.lower()
+                
+                if any(word in query_lower for word in ['price', 'bitcoin', 'btc', 'ethereum', 'eth', 'crypto']):
+                    suggested_tools.append('cryptocompare_data')
+                if 'defi' in query_lower or 'tvl' in query_lower:
+                    suggested_tools.append('defillama_data')
+                if 'ethereum' in query_lower or 'gas' in query_lower:
+                    suggested_tools.append('etherscan_data')
+                if any(word in query_lower for word in ['chart', 'graph', 'visualization', 'trend']):
+                    suggested_tools.append('chart_data_provider')
+                
+                # Default to basic crypto data if no matches
+                if not suggested_tools:
+                    suggested_tools = ['cryptocompare_data']
             
-            enhanced_query = f"""
-            Research Query: {query}
-            Research Plan: {research_plan.get('steps', [])}
-            Priority: {research_plan.get('priority', 'general')}
+            # Default to at least one relevant tool if parsing fails
+            if not suggested_tools:
+                if any(word in query.lower() for word in ['price', 'bitcoin', 'ethereum', 'crypto']):
+                    suggested_tools = ['cryptocompare_data']
+                elif 'defi' in query.lower() or 'tvl' in query.lower():
+                    suggested_tools = ['defillama_data']
+                else:
+                    suggested_tools = ['cryptocompare_data']
             
-            Execute systematic research and provide comprehensive analysis.
-            """
+            logger.info(f"🛠️ Ollama suggested tools: {suggested_tools}")
             
-            result = await asyncio.to_thread(
-                self.executor.invoke, {"input": enhanced_query}
-            )
+            # Step 2: Execute relevant tools
+            tool_results = []
+            try:
+                for tool_name in suggested_tools:
+                    tool = next((t for t in self.tools if t.name == tool_name), None)
+                    if tool:
+                        try:
+                            logger.info(f"🔧 Executing {tool_name}")
+                            
+                            # Handle chart_data_provider with proper parameters
+                            if tool_name == "chart_data_provider":
+                                # Extract chart type from query or default to price_chart
+                                chart_type = "price_chart"  # Default
+                                symbol = "bitcoin"  # Default
+                                
+                                if "defi" in query.lower() or "tvl" in query.lower():
+                                    chart_type = "defi_tvl"
+                                elif "market" in query.lower() or "overview" in query.lower():
+                                    chart_type = "market_overview"
+                                elif "gas" in query.lower():
+                                    chart_type = "gas_tracker"
+                                    
+                                # Extract symbol if mentioned
+                                if "ethereum" in query.lower() or "eth" in query.lower():
+                                    symbol = "ethereum"
+                                elif "bitcoin" in query.lower() or "btc" in query.lower():
+                                    symbol = "bitcoin"
+                                    
+                                result = await tool._arun(chart_type=chart_type, symbol=symbol)
+                            else:
+                                # Other tools use the query directly
+                                result = await tool._arun(query)
+                                
+                            logger.info(f"📊 {tool_name} result preview: {str(result)[:200]}...")
+                            tool_results.append(f"=== {tool_name} Results ===\n{result}\n")
+                        except Exception as e:
+                            logger.error(f"Tool {tool_name} failed: {e}")
+                            tool_results.append(f"=== {tool_name} Error ===\nTool failed: {str(e)}\n")
+                        finally:
+                            # Cleanup tool session if available
+                            if hasattr(tool, 'cleanup'):
+                                try:
+                                    await tool.cleanup()
+                                except Exception:
+                                    pass  # Ignore cleanup errors
+            finally:
+                # Ensure all tools are cleaned up
+                for tool in self.tools:
+                    if hasattr(tool, 'cleanup'):
+                        try:
+                            await tool.cleanup()
+                        except Exception:
+                            pass
+            
+            # Step 3: Generate final response with tool results using AI Safety
+            context = "\n".join(tool_results) if tool_results else "No tool data available - provide general information."
+            
+            # Use AI Safety to create a safe prompt
+            final_prompt = ai_safety.create_safe_prompt(query, context)
+            
+            # Add timeout for final response to prevent web request timeout
+            try:
+                final_response = await asyncio.wait_for(
+                    self.fallback_llm.ainvoke(final_prompt),
+                    timeout=440  # 90 second timeout for Llama 3.1 8B model
+                )
+                logger.info(f"🎯 Ollama final response preview: {str(final_response)[:300]}...")
+                
+                # Extract content from Ollama response
+                response_content = str(final_response)
+                
+                # AI Safety Check: Validate response
+                clean_response, response_safe, response_reason = ai_safety.validate_ollama_response(response_content)
+                if not response_safe:
+                    ai_safety.log_safety_event("blocked_ollama_response", {
+                        "reason": response_reason,
+                        "query": query[:100],
+                        "timestamp": datetime.now().isoformat()
+                    })
+                    # Use tool data directly instead of unsafe response
+                    clean_response = f"""## Cryptocurrency Analysis
+
+Based on the available data:
+
+{context[:1000]}
+
+*Response generated from verified tool data for safety compliance.*"""
+                
+                final_response = clean_response
+                
+            except asyncio.TimeoutError:
+                logger.warning("⏱️ Ollama final response timed out (60s), using enhanced tool summary")
+                # Create a better summary from the tool results
+                summary_parts = []
+                
+                if "cryptocompare_data" in suggested_tools:
+                    summary_parts.append("📊 **Price Data**: Live cryptocurrency prices retrieved")
+                if "defillama_data" in suggested_tools:
+                    summary_parts.append("🔒 **DeFi Data**: Protocol TVL and yield information available")
+                if "etherscan_data" in suggested_tools:
+                    summary_parts.append("⛓️ **Blockchain Data**: Ethereum network information gathered")
+                if "chart_data_provider" in suggested_tools:
+                    summary_parts.append("📈 **Chart Data**: Visualization data prepared")
+                
+                # Extract key data points from tool results
+                key_data = ""
+                if tool_results:
+                    for result in tool_results[:2]:  # Use first 2 tool results
+                        if "USD" in result:
+                            # Extract price info
+                            lines = result.split('\n')
+                            for line in lines:
+                                if "USD" in line and "$" in line:
+                                    key_data += f"\n{line.strip()}"
+                                    break
+                
+                final_response = f"""## {query.title()}
+
+{chr(10).join(summary_parts)}
+
+**Key Findings**:{key_data}
+
+The system successfully executed {len(suggested_tools)} data tools:
+• {', '.join(suggested_tools)}
+
+*Complete analysis available - AI processing optimized for speed.*"""
             
+            logger.info("✅ Research successful with Ollama + tools")
             return {
                 "success": True,
                 "query": query,
-                "research_plan": research_plan,
-                "result": result.get("output", "No response"),
-                "sources": self._extract_sources(result.get("output", "")),
+                "result": final_response,
+                "sources": [],
                 "metadata": {
-                    "tools_used": [tool.name for tool in self.tools],
+                    "llm_used": f"Ollama ({config.OLLAMA_MODEL})", 
+                    "tools_used": suggested_tools,
                     "timestamp": datetime.now().isoformat()
                 }
             }
             
         except Exception as e:
-            logger.error(f"Research error: {e}")
+            logger.error(f"Ollama tools research failed: {e}")
+            raise e
+
+    async def _research_with_gemini_tools(self, query: str, memory_context: Dict[str, Any] = None) -> Dict[str, Any]:
+        """Research using Gemini with tools - Enhanced with memory"""
+        try:
+            # Step 1: Analyze query and suggest tools using Gemini
+            # Include memory context if available
+            context_info = ""
+            if memory_context and memory_context.get("cached_context"):
+                recent_tools = []
+                for ctx in memory_context["cached_context"][:2]:  # Last 2 contexts
+                    if "tools_used" in ctx:
+                        recent_tools.extend(ctx["tools_used"])
+                if recent_tools:
+                    context_info = f"\n\nRecent tools used: {', '.join(set(recent_tools))}"
+            
+            tool_analysis_prompt = f"""Tools for: "{query}"{context_info}
+
+cryptocompare_data: crypto prices
+etherscan_data: Ethereum data
+defillama_data: DeFi TVL  
+chart_data_provider: charts
+
+List tool names:"""
+
+            try:
+                tool_response = await asyncio.wait_for(
+                    self.llm.ainvoke(tool_analysis_prompt),
+                    timeout=30  # 30 second timeout for Gemini tool analysis
+                )
+                
+                logger.info(f"🧠 Gemini tool analysis response: {str(tool_response)[:100]}...")
+                
+                # Parse suggested tools
+                suggested_tools = [tool.strip() for tool in str(tool_response).split(',') if tool.strip()]
+                suggested_tools = [tool for tool in suggested_tools if tool in {
+                    'cryptocompare_data', 'defillama_data', 
+                    'etherscan_data', 'chart_data_provider'
+                }]
+                
+                # If no valid tools found, extract from response content
+                if not suggested_tools:
+                    response_text = str(tool_response).lower()
+                    if 'cryptocompare' in response_text:
+                        suggested_tools.append('cryptocompare_data')
+                    if 'defillama' in response_text:
+                        suggested_tools.append('defillama_data')
+                    if 'etherscan' in response_text:
+                        suggested_tools.append('etherscan_data')
+                    if 'chart' in response_text or 'visualization' in response_text:
+                        suggested_tools.append('chart_data_provider')
+                        
+            except asyncio.TimeoutError:
+                logger.warning("⏱️ Gemini tool analysis timed out, using fallback tool selection")
+                # Same fallback logic as Ollama
+                suggested_tools = []
+                query_lower = query.lower()
+                
+                if any(word in query_lower for word in ['price', 'bitcoin', 'btc', 'ethereum', 'eth', 'crypto']):
+                    suggested_tools.append('cryptocompare_data')
+                if 'defi' in query_lower or 'tvl' in query_lower:
+                    suggested_tools.append('defillama_data')
+                if 'ethereum' in query_lower or 'gas' in query_lower:
+                    suggested_tools.append('etherscan_data')
+                if any(word in query_lower for word in ['chart', 'graph', 'visualization', 'trend']):
+                    suggested_tools.append('chart_data_provider')
+                
+                if not suggested_tools:
+                    suggested_tools = ['cryptocompare_data']
+            
+            logger.info(f"🛠️ Gemini suggested tools: {suggested_tools}")
+
+            # Step 2: Execute tools (same logic as Ollama version)
+            tool_results = []
+            try:
+                for tool_name in suggested_tools:
+                    tool = next((t for t in self.tools if t.name == tool_name), None)
+                    if tool:
+                        try:
+                            logger.info(f"🔧 Executing {tool_name}")
+                            
+                            # Handle chart_data_provider with proper parameters
+                            if tool_name == "chart_data_provider":
+                                chart_type = "price_chart"
+                                symbol = "bitcoin"
+                                
+                                if "defi" in query.lower() or "tvl" in query.lower():
+                                    chart_type = "defi_tvl"
+                                elif "market" in query.lower() or "overview" in query.lower():
+                                    chart_type = "market_overview"
+                                elif "gas" in query.lower():
+                                    chart_type = "gas_tracker"
+                                    
+                                if "ethereum" in query.lower() or "eth" in query.lower():
+                                    symbol = "ethereum"
+                                elif "bitcoin" in query.lower() or "btc" in query.lower():
+                                    symbol = "bitcoin"
+                                    
+                                result = await tool._arun(chart_type=chart_type, symbol=symbol)
+                            else:
+                                result = await tool._arun(query)
+                                
+                            logger.info(f"📊 {tool_name} result preview: {str(result)[:200]}...")
+                            tool_results.append(f"=== {tool_name} Results ===\n{result}\n")
+                        except Exception as e:
+                            logger.error(f"Tool {tool_name} failed: {e}")
+                            tool_results.append(f"=== {tool_name} Error ===\nTool failed: {str(e)}\n")
+                        finally:
+                            # Cleanup tool session if available
+                            if hasattr(tool, 'cleanup'):
+                                try:
+                                    await tool.cleanup()
+                                except Exception:
+                                    pass  # Ignore cleanup errors
+            finally:
+                # Ensure all tools are cleaned up
+                for tool in self.tools:
+                    if hasattr(tool, 'cleanup'):
+                        try:
+                            await tool.cleanup()
+                        except Exception:
+                            pass
+            
+            # Step 3: Generate final response with Gemini
+            context = "\n".join(tool_results) if tool_results else "No tool data available - provide general information."
+            
+            final_prompt = ai_safety.create_safe_prompt(query, context)
+            
+            try:
+                final_response = await asyncio.wait_for(
+                    self.llm.ainvoke(final_prompt),
+                    timeout=60  # 60 second timeout for complex analysis
+                )
+                logger.info(f"🎯 Gemini final response preview: {str(final_response)[:300]}...")
+                
+                # Extract content from Gemini response object
+                if hasattr(final_response, 'content'):
+                    response_content = final_response.content
+                    logger.info(f"✅ Extracted clean content: {response_content[:200]}...")
+                else:
+                    response_content = str(final_response)
+                    logger.warning(f"⚠️ Fallback to str() conversion: {response_content[:200]}...")
+                
+                # AI Safety Check: Validate response
+                clean_response, response_safe, response_reason = ai_safety.validate_gemini_response(response_content)
+                if not response_safe:
+                    ai_safety.log_safety_event("blocked_gemini_response", {
+                        "reason": response_reason,
+                        "query": query[:100],
+                        "timestamp": datetime.now().isoformat()
+                    })
+                    clean_response = f"## Cryptocurrency Analysis\n\nBased on the available data:\n\n{context[:1000]}\n\n*Response filtered for safety*"
+                
+                logger.info(f"🔒 Final clean response: {clean_response[:200]}...")
+                final_response = clean_response
+                
+            except asyncio.TimeoutError:
+                logger.warning("⏱️ Gemini final response timed out (60s), using enhanced tool summary")
+                
+                # Create enhanced summary from tools
+                summary_parts = []
+                if "cryptocompare_data" in suggested_tools:
+                    summary_parts.append("📊 **Market Data**: Real-time cryptocurrency prices")
+                if "defillama_data" in suggested_tools:
+                    summary_parts.append("🏛️ **DeFi Analytics**: Protocol TVL and performance metrics")
+                if "etherscan_data" in suggested_tools:
+                    summary_parts.append("⛓️ **On-Chain Data**: Ethereum blockchain insights")
+                if "chart_data_provider" in suggested_tools:
+                    summary_parts.append("📈 **Visualizations**: Chart data prepared")
+                
+                final_response = f"""## Web3 Research Analysis
+
+{chr(10).join(summary_parts)}
+
+**Data Sources Processed**: {len(suggested_tools)} tools executed successfully
+
+{context[:800] if context else 'Tool data processing completed'}
+
+*Analysis optimized for real-time delivery*"""
+            
+            logger.info("✅ Research successful with Gemini + tools")
+            
+            # Final safety check: ensure we're not returning raw LangChain objects
+            if isinstance(final_response, str):
+                if "additional_kwargs" in final_response or "response_metadata" in final_response:
+                    logger.error("🚨 CRITICAL: Raw LangChain metadata detected in final response!")
+                    final_response = "Response contains technical metadata and has been filtered for safety."
+            
             return {
-                "success": False,
+                "success": True,
                 "query": query,
-                "error": str(e),
-                "result": f"❌ **Research Error**: {str(e)}\n\nPlease try a different query or check your API configuration.",
+                "result": final_response,
                 "sources": [],
-                "metadata": {"timestamp": datetime.now().isoformat()}
+                "metadata": {
+                    "llm_used": f"Gemini ({self.llm.model_name if hasattr(self.llm, 'model_name') else 'gemini-1.5-flash'})", 
+                    "tools_used": suggested_tools,
+                    "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]:
+            logger.error(f"Gemini tools research failed: {e}")
+            # Fallback to Ollama if Gemini fails
+            logger.info("🔄 Falling back to Ollama due to Gemini error")
+            return await self._research_with_ollama_tools(query)
+
+    def _extract_sources(self, response: str) -> List[str]:
+        """Extract sources from response"""
+        # Simple source extraction - can be enhanced
         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")
+        if "CoinGecko" in response or "coingecko" in response.lower():
+            sources.append("CoinGecko")
+        if "DeFiLlama" in response or "defillama" in response.lower():
+            sources.append("DeFiLlama") 
+        if "Etherscan" in response or "etherscan" in response.lower():
+            sources.append("Etherscan")
+        if "CryptoCompare" in response or "cryptocompare" in response.lower():
+            sources.append("CryptoCompare")
         return sources
+
+    def get_conversation_history(self) -> Dict[str, Any]:
+        """Get conversation history from memory"""
+        return self.memory_manager.get_relevant_context("")
+    
+    def clear_conversation_memory(self):
+        """Clear conversation memory"""
+        self.memory_manager.clear_memory()
+        logger.info("🧠 Conversation memory cleared")
+    
+    def get_memory_stats(self) -> Dict[str, Any]:
+        """Get memory usage statistics"""
+        history = self.memory_manager.memory.load_memory_variables({})
+        return {
+            "total_interactions": len(history.get("chat_history", [])) // 2,  # Each interaction has input+output
+            "cached_contexts": len(self.memory_manager.context_cache),
+            "memory_enabled": True
+        }

src/tools/base_tool.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, Union
 from langchain.tools import BaseTool
-from pydantic import BaseModel, Field, PrivateAttr
+from pydantic import BaseModel, Field, PrivateAttr, field_validator
 import asyncio
 import aiohttp
 import hashlib
@@ -14,7 +14,19 @@ 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")
+    filters: Optional[Union[Dict[str, Any], str]] = Field(default=None, description="Additional filters (dict) or filter type (string)")
+
+    @field_validator('filters')
+    @classmethod
+    def validate_filters(cls, v):
+        if v is None:
+            return None
+        if isinstance(v, str):
+            # Convert string filter to dict format
+            return {"type": v}
+        if isinstance(v, dict):
+            return v
+        return None
 
 class BaseWeb3Tool(BaseTool, ABC):
     name: str = "base_web3_tool"
@@ -72,11 +84,11 @@ class BaseWeb3Tool(BaseTool, ABC):
         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:
+    def _run(self, query: str, filters: Optional[Dict[str, Any]] = None, **kwargs) -> str:
         return asyncio.run(self._arun(query, filters))
-    
+
     @abstractmethod
-    async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None) -> str:
+    async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None, **kwargs) -> str:
         pass
 
     async def cleanup(self):

src/tools/chart_creator_tool.py

@@ -0,0 +1,356 @@
+from langchain.tools import BaseTool
+from pydantic import BaseModel, Field
+from typing import Dict, Any, List, Optional
+import json
+import asyncio
+from datetime import datetime
+
+from src.visualizations import CryptoVisualizations
+from src.tools.coingecko_tool import CoinGeckoTool
+from src.tools.defillama_tool import DeFiLlamaTool
+from src.tools.etherscan_tool import EtherscanTool
+from src.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+class ChartCreatorInput(BaseModel):
+    """Input schema for chart creation requests - accepts only essential parameters"""
+    chart_type: str = Field(
+        description="Chart type: price_chart, market_overview, defi_tvl, portfolio_pie, gas_tracker"
+    )
+    symbol: Optional[str] = Field(
+        default=None,
+        description="Asset symbol (e.g., bitcoin, ethereum) for price/market charts"
+    )
+    timeframe: Optional[str] = Field(
+        default="30d",
+        description="Time range: 1d, 7d, 30d, 90d, 365d"
+    )
+    protocols: Optional[List[str]] = Field(
+        default=None,
+        description="Protocol names for DeFi TVL charts (e.g., ['uniswap', 'aave'])"
+    )
+    network: Optional[str] = Field(
+        default="ethereum",
+        description="Blockchain network for gas tracker (ethereum, polygon, etc.)"
+    )
+
+class ChartCreatorTool(BaseTool):
+    """
+    Intelligent Chart Creator Tool
+    
+    This tool can create various types of cryptocurrency and DeFi charts by:
+    1. Understanding chart requirements from natural language
+    2. Fetching appropriate data from available sources
+    3. Generating professional visualizations
+    """
+    
+    name: str = "chart_creator"
+    description: str = """Create cryptocurrency and DeFi charts with specific parameters only.
+    
+    IMPORTANT: Only pass essential chart parameters - do not send full user queries.
+    
+    Chart types and required parameters:
+    - price_chart: symbol (e.g., "bitcoin"), timeframe (e.g., "30d")
+    - market_overview: symbol (optional), timeframe (default "30d")
+    - defi_tvl: protocols (list of protocol names), timeframe (optional)
+    - portfolio_pie: No parameters needed (uses default allocation)
+    - gas_tracker: network (e.g., "ethereum"), timeframe (optional)
+    
+    Examples of CORRECT usage:
+    - price_chart for Bitcoin: symbol="bitcoin", timeframe="30d"
+    - DeFi TVL chart: protocols=["uniswap", "aave"], timeframe="7d"
+    - Gas tracker: network="ethereum", timeframe="1d"
+    """
+    
+    # Define fields
+    viz: Any = None
+    coingecko: Any = None
+    defillama: Any = None
+    etherscan: Any = None
+    
+    args_schema: type[ChartCreatorInput] = ChartCreatorInput
+    
+    def __init__(self):
+        super().__init__()
+        self.viz = CryptoVisualizations()
+        self.coingecko = CoinGeckoTool()
+        self.defillama = DeFiLlamaTool()
+        self.etherscan = EtherscanTool()
+    
+    def _run(self, chart_type: str, symbol: str = None, timeframe: str = "30d", 
+             protocols: List[str] = None, network: str = "ethereum") -> str:
+        """Synchronous execution (not used in async context)"""
+        return asyncio.run(self._arun(chart_type, symbol, timeframe, protocols, network))
+    
+    async def _arun(self, chart_type: str, symbol: str = None, timeframe: str = "30d", 
+                    protocols: List[str] = None, network: str = "ethereum") -> str:
+        """Create charts with controlled parameters"""
+        try:
+            logger.info(f"Creating {chart_type} chart for {symbol or 'general'} with timeframe {timeframe}")
+            
+            # Build parameters from clean inputs
+            parameters = {
+                "symbol": symbol,
+                "timeframe": timeframe,
+                "protocols": protocols,
+                "network": network,
+                "days": self._parse_timeframe(timeframe)
+            }
+            
+            # Determine data source based on chart type
+            data_source = self._get_data_source(chart_type)
+            
+            # Fetch data based on source and chart type
+            data = await self._fetch_chart_data(chart_type, parameters, data_source)
+            
+            if not data:
+                return json.dumps({
+                    "status": "error",
+                    "message": f"Unable to fetch data for {chart_type} from {data_source}",
+                    "alternative": f"Try requesting textual analysis instead, or use different parameters",
+                    "chart_html": None
+                })
+            
+            # Create the appropriate chart
+            chart_html = await self._create_chart(chart_type, data, parameters)
+            
+            if chart_html:
+                logger.info(f"Successfully created {chart_type} chart")
+                return json.dumps({
+                    "status": "success",
+                    "message": f"Successfully created {chart_type} chart",
+                    "chart_html": chart_html,
+                    "data_source": data_source
+                })
+            else:
+                return json.dumps({
+                    "status": "error",
+                    "message": f"Chart creation failed for {chart_type}",
+                    "alternative": f"Data was retrieved but visualization failed. Providing textual analysis instead.",
+                    "chart_html": None
+                })
+                
+        except Exception as e:
+            logger.error(f"Chart creation error: {e}")
+            return json.dumps({
+                "status": "error", 
+                "message": f"Chart creation failed: {str(e)}",
+                "alternative": "Please try again with different parameters or request textual analysis",
+                "chart_html": None
+            })
+    
+    async def _fetch_chart_data(self, chart_type: str, parameters: Dict[str, Any], data_source: str) -> Optional[Dict[str, Any]]:
+        """Fetch data from appropriate source based on chart type"""
+        try:
+            if data_source == "coingecko":
+                return await self._fetch_coingecko_data(chart_type, parameters)
+            elif data_source == "defillama":
+                return await self._fetch_defillama_data(chart_type, parameters)
+            elif data_source == "etherscan":
+                return await self._fetch_etherscan_data(chart_type, parameters)
+            else:
+                logger.warning(f"Unknown data source: {data_source}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Data fetch error: {e}")
+            return None
+    
+    async def _fetch_coingecko_data(self, chart_type: str, parameters: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Fetch data from CoinGecko API"""
+        try:
+            if chart_type == "price_chart":
+                symbol = parameters.get("symbol", "bitcoin")
+                days = parameters.get("days", 30)
+                
+                                # Create mock price data
+                base_timestamp = 1704067200000  # Jan 1, 2024
+                mock_data = {
+                    "prices": [[base_timestamp + i * 86400000, 35000 + i * 100 + (i % 7) * 500] for i in range(days)],
+                    "total_volumes": [[base_timestamp + i * 86400000, 1000000 + i * 10000 + (i % 5) * 50000] for i in range(days)],
+                    "symbol": symbol,
+                    "days": days
+                }
+                return mock_data
+                
+            elif chart_type == "market_overview":
+                # Create mock market data
+                mock_data = {
+                    "coins": [
+                        {"name": "Bitcoin", "symbol": "BTC", "current_price": 35000, "market_cap_rank": 1, "price_change_percentage_24h": 2.5},
+                        {"name": "Ethereum", "symbol": "ETH", "current_price": 1800, "market_cap_rank": 2, "price_change_percentage_24h": -1.2},
+                        {"name": "Cardano", "symbol": "ADA", "current_price": 0.25, "market_cap_rank": 3, "price_change_percentage_24h": 3.1}
+                    ]
+                }
+                return mock_data
+                
+        except Exception as e:
+            logger.error(f"CoinGecko data fetch error: {e}")
+            
+        return None
+    
+    async def _fetch_defillama_data(self, chart_type: str, parameters: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Fetch data from DeFiLlama API"""
+        try:
+            if chart_type == "defi_tvl":
+                protocols = parameters.get("protocols", ["uniswap", "aave", "compound"])
+                # Create mock TVL data
+                mock_data = {
+                    "protocols": [
+                        {"name": "Uniswap", "tvl": 3500000000, "change_24h": 2.1},
+                        {"name": "Aave", "tvl": 5200000000, "change_24h": -0.8},
+                        {"name": "Compound", "tvl": 1800000000, "change_24h": 1.5}
+                    ]
+                }
+                return mock_data
+                
+        except Exception as e:
+            logger.error(f"DeFiLlama data fetch error: {e}")
+            
+        return None
+    
+    async def _fetch_etherscan_data(self, chart_type: str, parameters: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Fetch data from Etherscan API"""
+        try:
+            if chart_type == "gas_tracker":
+                # Create mock gas data
+                mock_data = {
+                    "gas_prices": {
+                        "safe": 15,
+                        "standard": 20,
+                        "fast": 35,
+                        "instant": 50
+                    },
+                    "network": "ethereum"
+                }
+                return mock_data
+                
+        except Exception as e:
+            logger.error(f"Etherscan data fetch error: {e}")
+            
+        return None
+    
+    async def _create_chart(self, chart_type: str, data: Dict[str, Any], parameters: Dict[str, Any]) -> Optional[str]:
+        """Create chart using the visualization module"""
+        try:
+            fig = None
+            
+            if chart_type == "price_chart":
+                symbol = parameters.get("symbol", "BTC")
+                fig = self.viz.create_price_chart(data, symbol)
+                
+            elif chart_type == "market_overview":
+                # Convert dict to list format expected by visualization
+                market_data = []
+                if isinstance(data, dict) and "data" in data:
+                    market_data = data["data"]
+                elif isinstance(data, list):
+                    market_data = data
+                fig = self.viz.create_market_overview(market_data)
+                
+            elif chart_type == "defi_tvl":
+                # Convert to format expected by visualization
+                tvl_data = []
+                if isinstance(data, dict):
+                    tvl_data = [data]  # Wrap single protocol in list
+                elif isinstance(data, list):
+                    tvl_data = data
+                fig = self.viz.create_defi_tvl_chart(tvl_data)
+                
+            elif chart_type == "portfolio_pie":
+                portfolio_data = parameters.get("portfolio", {})
+                if not portfolio_data and isinstance(data, dict):
+                    portfolio_data = data
+                fig = self.viz.create_portfolio_pie_chart(portfolio_data)
+                
+            elif chart_type == "gas_tracker":
+                fig = self.viz.create_gas_tracker(data)
+            
+            if fig:
+                # Convert to HTML
+                chart_html = fig.to_html(
+                    include_plotlyjs='cdn',
+                    div_id=f"chart_{chart_type}_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+                    config={'displayModeBar': True, 'responsive': True}
+                )
+                
+                # Store chart for later retrieval (you could save to database/cache here)
+                return chart_html
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"Chart creation error: {e}")
+            return None
+
+    def get_chart_suggestions(self, query: str) -> List[Dict[str, Any]]:
+        """Generate chart suggestions based on user query"""
+        suggestions = []
+        
+        query_lower = query.lower()
+        
+        # Price-related queries
+        if any(word in query_lower for word in ["price", "chart", "trend", "bitcoin", "ethereum", "crypto"]):
+            suggestions.append({
+                "chart_type": "price_chart",
+                "description": "Price and volume chart with historical data",
+                "parameters": {"symbol": "bitcoin", "days": 30},
+                "data_source": "coingecko"
+            })
+        
+        # Market overview queries
+        if any(word in query_lower for word in ["market", "overview", "top", "comparison", "ranking"]):
+            suggestions.append({
+                "chart_type": "market_overview",
+                "description": "Market cap and performance overview of top cryptocurrencies",
+                "parameters": {"limit": 20},
+                "data_source": "coingecko"
+            })
+        
+        # DeFi queries
+        if any(word in query_lower for word in ["defi", "tvl", "protocol", "uniswap", "aave", "compound"]):
+            suggestions.append({
+                "chart_type": "defi_tvl",
+                "description": "DeFi protocol Total Value Locked comparison",
+                "parameters": {"protocols": ["uniswap", "aave", "compound"]},
+                "data_source": "defillama"
+            })
+        
+        # Gas fee queries
+        if any(word in query_lower for word in ["gas", "fee", "ethereum", "network", "transaction"]):
+            suggestions.append({
+                "chart_type": "gas_tracker",
+                "description": "Ethereum gas fee tracker",
+                "parameters": {"network": "ethereum"},
+                "data_source": "etherscan"
+            })
+        
+        # Portfolio queries
+        if any(word in query_lower for word in ["portfolio", "allocation", "distribution", "holdings"]):
+            suggestions.append({
+                "chart_type": "portfolio_pie",
+                "description": "Portfolio allocation pie chart",
+                "parameters": {"portfolio": {"BTC": 40, "ETH": 30, "ADA": 20, "DOT": 10}},
+                "data_source": "custom"
+            })
+        
+        return suggestions[:3]  # Return top 3 suggestions
+
+    def _parse_timeframe(self, timeframe: str) -> int:
+        """Convert timeframe string to days"""
+        timeframe_map = {
+            "1d": 1, "7d": 7, "30d": 30, "90d": 90, "365d": 365, "1y": 365
+        }
+        return timeframe_map.get(timeframe, 30)
+    
+    def _get_data_source(self, chart_type: str) -> str:
+        """Determine appropriate data source for chart type"""
+        source_map = {
+            "price_chart": "coingecko",
+            "market_overview": "coingecko", 
+            "defi_tvl": "defillama",
+            "portfolio_pie": "custom",
+            "gas_tracker": "etherscan"
+        }
+        return source_map.get(chart_type, "coingecko")

src/tools/chart_data_tool.py

@@ -0,0 +1,390 @@
+from langchain.tools import BaseTool
+from pydantic import BaseModel, Field
+from typing import Dict, Any, List, Optional
+import json
+import asyncio
+
+from src.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+class ChartDataInput(BaseModel):
+    """Input schema for chart data requests"""
+    chart_type: str = Field(description="Chart type: price_chart, market_overview, defi_tvl, portfolio_pie, gas_tracker")
+    symbol: Optional[str] = Field(default=None, description="Asset symbol (e.g., bitcoin, ethereum)")
+    timeframe: Optional[str] = Field(default="30d", description="Time range: 1d, 7d, 30d, 90d, 365d")
+    protocols: Optional[List[str]] = Field(default=None, description="DeFi protocol names")
+    network: Optional[str] = Field(default="ethereum", description="Blockchain network")
+
+class ChartDataTool(BaseTool):
+    """
+    Chart Data Provider Tool
+    
+    This tool provides structured data that can be used to create charts.
+    Instead of returning HTML, it returns clean JSON data for visualization.
+    """
+    
+    name: str = "chart_data_provider"
+    description: str = """Provides structured data for creating cryptocurrency charts.
+    
+    Returns JSON data in this format:
+    {{
+        "chart_type": "price_chart|market_overview|defi_tvl|portfolio_pie|gas_tracker",
+        "data": {{...}},
+        "config": {{...}}
+    }}
+    
+    Chart types:
+    - price_chart: Bitcoin/crypto price and volume data
+    - market_overview: Top cryptocurrencies market data  
+    - defi_tvl: DeFi protocol TVL comparison
+    - portfolio_pie: Portfolio allocation breakdown
+    - gas_tracker: Gas fees across networks
+    """
+    
+    args_schema: type[ChartDataInput] = ChartDataInput
+    
+    def _run(self, chart_type: str, symbol: str = None, timeframe: str = "30d", 
+             protocols: List[str] = None, network: str = "ethereum") -> str:
+        """Synchronous execution"""
+        return asyncio.run(self._arun(chart_type, symbol, timeframe, protocols, network))
+    
+    async def _arun(self, chart_type: str, symbol: str = None, timeframe: str = "30d", 
+                   protocols: List[str] = None, network: str = "ethereum") -> str:
+        """Asynchronous execution with proper session cleanup"""
+        try:
+            logger.info(f"Providing {chart_type} data for {symbol or 'general'}")
+            
+            if chart_type == "price_chart":
+                if not symbol:
+                    symbol = "bitcoin"  # Default symbol
+                days = {"1d": 1, "7d": 7, "30d": 30, "90d": 90, "365d": 365}.get(timeframe, 30)
+                result = await self._get_price_chart_data(symbol, days)
+            elif chart_type == "market_overview":
+                result = await self._get_market_overview_data()
+            elif chart_type == "defi_tvl":
+                result = await self._get_defi_tvl_data(protocols)
+            elif chart_type == "portfolio_pie":
+                result = await self._get_portfolio_data()
+            elif chart_type == "gas_tracker":
+                result = await self._get_gas_tracker_data(network)
+            else:
+                result = json.dumps({
+                    "chart_type": "error",
+                    "error": f"Unknown chart type: {chart_type}",
+                    "available_types": ["price_chart", "market_overview", "defi_tvl", "portfolio_pie", "gas_tracker"]
+                })
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Chart data generation failed: {e}")
+            return json.dumps({
+                "chart_type": "error",
+                "error": str(e),
+                "message": "Failed to generate chart data"
+            })
+        finally:
+            # Ensure session cleanup
+            await self.cleanup()
+
+    async def _get_price_chart_data(self, symbol: str, days: int) -> str:
+        """Get price chart data with fallback for API failures"""
+        cryptocompare_tool = None
+        try:
+            # First try to get real data from CryptoCompare (we have this API key)
+            from src.tools.cryptocompare_tool import CryptoCompareTool
+            
+            cryptocompare_tool = CryptoCompareTool()
+            
+            # Map common symbols to CryptoCompare format
+            symbol_map = {
+                "btc": "BTC", "bitcoin": "BTC",
+                "eth": "ethereum", "ethereum": "ETH", 
+                "sol": "SOL", "solana": "SOL",
+                "ada": "ADA", "cardano": "ADA",
+                "bnb": "BNB", "binance": "BNB",
+                "matic": "MATIC", "polygon": "MATIC",
+                "avax": "AVAX", "avalanche": "AVAX",
+                "dot": "DOT", "polkadot": "DOT",
+                "link": "LINK", "chainlink": "LINK",
+                "uni": "UNI", "uniswap": "UNI"
+            }
+            
+            crypto_symbol = symbol_map.get(symbol.lower(), symbol.upper())
+            
+            try:
+                # Use CryptoCompare for price data
+                query = f"{crypto_symbol} price historical {days} days"
+                data_result = await cryptocompare_tool._arun(query, {"type": "price_history", "days": days})
+                
+                if data_result and not data_result.startswith("❌") and not data_result.startswith("⚠️"):
+                    return json.dumps({
+                        "chart_type": "price_chart", 
+                        "data": {
+                            "source": "cryptocompare",
+                            "raw_data": data_result,
+                            "symbol": crypto_symbol,
+                            "name": symbol.title()
+                        },
+                        "config": {
+                            "title": f"{symbol.title()} Price Analysis ({days} days)",
+                            "timeframe": f"{days}d", 
+                            "currency": "USD"
+                        }
+                    })
+                else:
+                    raise Exception("No valid price data from CryptoCompare")
+                    
+            except Exception as api_error:
+                logger.error(f"CryptoCompare price data failed: {api_error}")
+                # Fallback to mock data on any API error
+                logger.info(f"Using fallback mock data for {symbol}")
+                return await self._get_mock_price_data(symbol, days)
+            
+        except Exception as e:
+            logger.error(f"Price chart data generation failed: {e}")
+            # Final fallback to mock data
+            return await self._get_mock_price_data(symbol, days)
+        finally:
+            # Cleanup CryptoCompare tool session
+            if cryptocompare_tool and hasattr(cryptocompare_tool, 'cleanup'):
+                try:
+                    await cryptocompare_tool.cleanup()
+                except Exception:
+                    pass  # Ignore cleanup errors
+    
+    async def _get_mock_price_data(self, symbol: str, days: int) -> str:
+        """Fallback mock price data"""
+        import time
+        import random
+        
+        base_price = 35000 if symbol.lower() == "bitcoin" else 1800 if symbol.lower() == "ethereum" else 100
+        base_timestamp = int(time.time() * 1000) - (days * 24 * 60 * 60 * 1000)
+        
+        price_data = []
+        volume_data = []
+        
+        for i in range(days):
+            timestamp = base_timestamp + (i * 24 * 60 * 60 * 1000)
+            price_change = random.uniform(-0.05, 0.05)
+            price = base_price * (1 + price_change * i / days)
+            price += random.uniform(-price*0.02, price*0.02)
+            volume = random.uniform(1000000000, 5000000000)
+            
+            price_data.append([timestamp, round(price, 2)])
+            volume_data.append([timestamp, int(volume)])
+        
+        return json.dumps({
+            "chart_type": "price_chart",
+            "data": {
+                "prices": price_data,
+                "total_volumes": volume_data,
+                "symbol": symbol.upper(),
+                "name": symbol.title()
+            },
+            "config": {
+                "title": f"{symbol.title()} Price Analysis ({days} days)",
+                "timeframe": f"{days}d",
+                "currency": "USD"
+            }
+        })
+    
+    async def _get_market_overview_data(self) -> str:
+        """Get market overview data using CryptoCompare API"""
+        cryptocompare_tool = None
+        try:
+            from src.tools.cryptocompare_tool import CryptoCompareTool
+            
+            cryptocompare_tool = CryptoCompareTool()
+            
+            # Get market overview using CryptoCompare
+            query = "top cryptocurrencies market cap overview"
+            data_result = await cryptocompare_tool._arun(query, {"type": "market_overview"})
+            
+            if data_result and not data_result.startswith("❌") and not data_result.startswith("⚠️"):
+                return json.dumps({
+                    "chart_type": "market_overview",
+                    "data": {
+                        "source": "cryptocompare",
+                        "raw_data": data_result
+                    },
+                    "config": {
+                        "title": "Top Cryptocurrencies Market Overview",
+                        "currency": "USD"
+                    }
+                })
+            else:
+                raise Exception("No valid market data from CryptoCompare")
+            
+        except Exception as e:
+            logger.error(f"Market overview API failed: {e}")
+            return await self._get_mock_market_data()
+        finally:
+            # Cleanup CryptoCompare tool session
+            if cryptocompare_tool and hasattr(cryptocompare_tool, 'cleanup'):
+                try:
+                    await cryptocompare_tool.cleanup()
+                except Exception:
+                    pass  # Ignore cleanup errors
+    
+    async def _get_mock_market_data(self) -> str:
+        """Fallback mock market data"""
+        return json.dumps({
+            "chart_type": "market_overview",
+            "data": {
+                "coins": [
+                    {"name": "Bitcoin", "symbol": "BTC", "current_price": 35000, "market_cap_rank": 1, "price_change_percentage_24h": 2.5},
+                    {"name": "Ethereum", "symbol": "ETH", "current_price": 1800, "market_cap_rank": 2, "price_change_percentage_24h": -1.2},
+                    {"name": "Cardano", "symbol": "ADA", "current_price": 0.25, "market_cap_rank": 3, "price_change_percentage_24h": 3.1},
+                    {"name": "Solana", "symbol": "SOL", "current_price": 22.5, "market_cap_rank": 4, "price_change_percentage_24h": -2.8},
+                    {"name": "Polygon", "symbol": "MATIC", "current_price": 0.52, "market_cap_rank": 5, "price_change_percentage_24h": 1.9}
+                ]
+            },
+            "config": {
+                "title": "Top Cryptocurrencies Market Overview",
+                "currency": "USD"
+            }
+        })
+    
+    async def _get_defi_tvl_data(self, protocols: List[str]) -> str:
+        """Get real DeFi TVL data from DeFiLlama API"""
+        try:
+            from src.tools.defillama_tool import DeFiLlamaTool
+            
+            defillama = DeFiLlamaTool()
+            
+            # Get protocols data
+            data = await defillama.make_request(f"{defillama._base_url}/protocols")
+            
+            if not data:
+                logger.warning("DeFiLlama API failed, using fallback")
+                return await self._get_mock_defi_data(protocols)
+            
+            # Filter for requested protocols or top protocols
+            if protocols:
+                filtered_protocols = []
+                for protocol_name in protocols:
+                    for protocol in data:
+                        if protocol_name.lower() in protocol.get("name", "").lower():
+                            filtered_protocols.append(protocol)
+                            break
+                protocols_data = filtered_protocols[:8]  # Limit to 8
+            else:
+                # Get top protocols by TVL (filter out None values)
+                valid_protocols = [p for p in data if p.get("tvl") is not None and p.get("tvl", 0) > 0]
+                protocols_data = sorted(valid_protocols, key=lambda x: x.get("tvl", 0), reverse=True)[:8]
+            
+            if not protocols_data:
+                return await self._get_mock_defi_data(protocols)
+            
+            # Format TVL data
+            tvl_data = []
+            for protocol in protocols_data:
+                tvl_data.append({
+                    "name": protocol.get("name", "Unknown"),
+                    "tvl": protocol.get("tvl", 0),
+                    "change_1d": protocol.get("change_1d", 0),
+                    "chain": protocol.get("chain", "Multi-chain"),
+                    "category": protocol.get("category", "DeFi")
+                })
+            
+            return json.dumps({
+                "chart_type": "defi_tvl",
+                "data": {"protocols": tvl_data},
+                "config": {
+                    "title": "DeFi Protocols by Total Value Locked",
+                    "currency": "USD"
+                }
+            })
+            
+        except Exception as e:
+            logger.error(f"DeFi TVL API failed: {e}")
+            return await self._get_mock_defi_data(protocols)
+    
+    async def _get_mock_defi_data(self, protocols: List[str]) -> str:
+        """Fallback mock DeFi data"""
+        import random
+        
+        protocol_names = protocols or ["Uniswap", "Aave", "Compound", "Curve", "MakerDAO"]
+        tvl_data = []
+        
+        for protocol in protocol_names[:5]:
+            tvl = random.uniform(500000000, 5000000000)
+            change = random.uniform(-10, 15)
+            tvl_data.append({
+                "name": protocol,
+                "tvl": tvl,
+                "change_1d": change,
+                "chain": "Ethereum",
+                "category": "DeFi"
+            })
+        
+        return json.dumps({
+            "chart_type": "defi_tvl",
+            "data": {"protocols": tvl_data},
+            "config": {
+                "title": "DeFi Protocols by Total Value Locked",
+                "currency": "USD"
+            }
+        })
+    
+    async def _get_portfolio_data(self) -> str:
+        """Get portfolio allocation data"""
+        return json.dumps({
+            "chart_type": "portfolio_pie",
+            "data": {
+                "allocations": [
+                    {"name": "Bitcoin", "symbol": "BTC", "value": 40, "color": "#f7931a"},
+                    {"name": "Ethereum", "symbol": "ETH", "value": 30, "color": "#627eea"},
+                    {"name": "Cardano", "symbol": "ADA", "value": 15, "color": "#0033ad"},
+                    {"name": "Solana", "symbol": "SOL", "value": 10, "color": "#9945ff"},
+                    {"name": "Other", "symbol": "OTHER", "value": 5, "color": "#666666"}
+                ]
+            },
+            "config": {
+                "title": "Sample Portfolio Allocation",
+                "currency": "Percentage"
+            }
+        })
+    
+    async def _get_gas_data(self, network: str) -> str:
+        """Get gas fee data"""
+        import random
+        import time
+        
+        # Generate 24 hours of gas data
+        gas_data = []
+        base_timestamp = int(time.time() * 1000) - (24 * 60 * 60 * 1000)
+        
+        for i in range(24):
+            timestamp = base_timestamp + (i * 60 * 60 * 1000)
+            gas_price = random.uniform(20, 100) if network == "ethereum" else random.uniform(1, 10)
+            gas_data.append([timestamp, round(gas_price, 2)])
+        
+        return json.dumps({
+            "chart_type": "gas_tracker",
+            "data": {
+                "gas_prices": gas_data,
+                "network": network.title()
+            },
+            "config": {
+                "title": f"{network.title()} Gas Fee Tracker (24h)",
+                "unit": "Gwei"
+            }
+        })
+    
+    def _parse_timeframe(self, timeframe: str) -> int:
+        """Convert timeframe string to days"""
+        timeframe_map = {
+            "1d": 1, "7d": 7, "30d": 30, "90d": 90, "365d": 365, "1y": 365
+        }
+        return timeframe_map.get(timeframe, 30)
+    
+    async def cleanup(self):
+        """Cleanup method for session management"""
+        # ChartDataTool creates temporary tools that may have sessions
+        # Since we don't maintain persistent references, sessions should auto-close
+        # But we can force garbage collection to ensure cleanup
+        import gc
+        gc.collect()

src/tools/coingecko_tool.py

@@ -23,7 +23,7 @@ class CoinGeckoTool(BaseWeb3Tool):
     def __init__(self):
         super().__init__()
 
-    async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None) -> str:
+    async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None, **kwargs) -> str:
         filters = filters or {}
         try:
             # Check cache first

src/tools/cryptocompare_tool.py

@@ -0,0 +1,253 @@
+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 CryptoCompareTool(BaseWeb3Tool):
+    name: str = "cryptocompare_data"
+    description: str = """Get cryptocurrency price, volume, and market data from CryptoCompare API.
+    Useful for: real-time prices, historical data, market analysis, volume tracking.
+    Input: cryptocurrency symbol or query (e.g., BTC, ETH, price analysis)."""
+    args_schema: type[BaseModel] = Web3ToolInput
+    
+    _base_url: str = PrivateAttr(default="https://min-api.cryptocompare.com/data")
+    
+    def __init__(self):
+        super().__init__()
+        # Store API key as instance variable instead of using Pydantic field
+        self._api_key = config.CRYPTOCOMPARE_API_KEY
+    
+    async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None, **kwargs) -> str:
+        """Get crypto data from CryptoCompare API"""
+        try:
+            filters = filters or {}
+            query_lower = query.lower()
+            
+            # Extract cryptocurrency symbols
+            common_symbols = {
+                "bitcoin": "BTC", "btc": "BTC",
+                "ethereum": "ETH", "eth": "ETH", 
+                "solana": "SOL", "sol": "SOL",
+                "cardano": "ADA", "ada": "ADA",
+                "polygon": "MATIC", "matic": "MATIC",
+                "avalanche": "AVAX", "avax": "AVAX",
+                "chainlink": "LINK", "link": "LINK",
+                "uniswap": "UNI", "uni": "UNI",
+                "polkadot": "DOT", "dot": "DOT",
+                "binance": "BNB", "bnb": "BNB"
+            }
+            
+            # Find symbol in query
+            symbol = None
+            for key, value in common_symbols.items():
+                if key in query_lower:
+                    symbol = value
+                    break
+            
+            if not symbol:
+                # Try to extract uppercase words as potential symbols
+                words = query.upper().split()
+                potential_symbols = [w for w in words if w.isalpha() and len(w) <= 5]
+                symbol = potential_symbols[0] if potential_symbols else "BTC"
+            
+            # Determine data type needed
+            if any(word in query_lower for word in ["price", "cost", "value", "current"]):
+                return await self._get_current_price(symbol)
+            elif any(word in query_lower for word in ["history", "historical", "trend", "chart"]):
+                return await self._get_historical_data(symbol)
+            elif any(word in query_lower for word in ["volume", "trading"]):
+                return await self._get_volume_data(symbol)
+            else:
+                # Default to current price + basic stats
+                return await self._get_current_price(symbol)
+                
+        except Exception as e:
+            logger.error(f"CryptoCompare error: {e}")
+            return f"⚠️ CryptoCompare data temporarily unavailable: {str(e)}"
+    
+    async def _get_current_price(self, symbol: str) -> str:
+        """Get current price and basic stats"""
+        try:
+            # Current price endpoint
+            params = {
+                "fsym": symbol,
+                "tsyms": "USD,EUR,BTC",
+                "extraParams": "Web3ResearchAgent"
+            }
+            
+            if self._api_key:
+                params["api_key"] = self._api_key
+            
+            price_data = await self.make_request(f"{self._base_url}/price", params=params)
+            
+            if not price_data:
+                return f"❌ No price data available for {symbol}"
+            
+            # Get additional stats
+            stats_params = {
+                "fsym": symbol,
+                "tsym": "USD",
+                "extraParams": "Web3ResearchAgent"
+            }
+            
+            if self._api_key:
+                stats_params["api_key"] = self._api_key
+            
+            stats_data = await self.make_request(f"{self._base_url}/pricemultifull", params=stats_params)
+            
+            # Format response
+            usd_price = price_data.get("USD", 0)
+            eur_price = price_data.get("EUR", 0)
+            btc_price = price_data.get("BTC", 0)
+            
+            result = f"💰 **{symbol} Current Price** (CryptoCompare):\n\n"
+            result += f"🇺🇸 **USD**: ${usd_price:,.2f}\n"
+            
+            if eur_price > 0:
+                result += f"🇪🇺 **EUR**: €{eur_price:,.2f}\n"
+            if btc_price > 0:
+                result += f"₿ **BTC**: {btc_price:.8f}\n"
+            
+            # Add stats if available
+            if stats_data and "RAW" in stats_data:
+                raw_data = stats_data["RAW"].get(symbol, {}).get("USD", {})
+                
+                if raw_data:
+                    change_24h = raw_data.get("CHANGEPCT24HOUR", 0)
+                    volume_24h = raw_data.get("VOLUME24HOUR", 0)
+                    market_cap = raw_data.get("MKTCAP", 0)
+                    
+                    emoji = "📈" if change_24h >= 0 else "📉"
+                    result += f"\n📊 **24h Change**: {change_24h:+.2f}% {emoji}\n"
+                    
+                    if volume_24h > 0:
+                        result += f"📈 **24h Volume**: ${volume_24h:,.0f}\n"
+                    
+                    if market_cap > 0:
+                        result += f"🏦 **Market Cap**: ${market_cap:,.0f}\n"
+            
+            result += f"\n🕒 *Real-time data from CryptoCompare*"
+            return result
+            
+        except Exception as e:
+            logger.error(f"Price data error: {e}")
+            return f"⚠️ Unable to fetch {symbol} price data"
+    
+    async def _get_historical_data(self, symbol: str, days: int = 30) -> str:
+        """Get historical price data"""
+        try:
+            params = {
+                "fsym": symbol,
+                "tsym": "USD", 
+                "limit": min(days, 365),
+                "extraParams": "Web3ResearchAgent"
+            }
+            
+            if self._api_key:
+                params["api_key"] = self._api_key
+            
+            hist_data = await self.make_request(f"{self._base_url}/histoday", params=params)
+            
+            if not hist_data or "Data" not in hist_data:
+                return f"❌ No historical data available for {symbol}"
+            
+            data_points = hist_data["Data"]
+            if not data_points:
+                return f"❌ No historical data points for {symbol}"
+            
+            # Get first and last prices
+            first_price = data_points[0].get("close", 0)
+            last_price = data_points[-1].get("close", 0)
+            
+            # Calculate performance
+            if first_price > 0:
+                performance = ((last_price - first_price) / first_price) * 100
+                performance_emoji = "📈" if performance >= 0 else "📉"
+            else:
+                performance = 0
+                performance_emoji = "➡️"
+            
+            # Find highest and lowest
+            high_price = max([p.get("high", 0) for p in data_points])
+            low_price = min([p.get("low", 0) for p in data_points if p.get("low", 0) > 0])
+            
+            result = f"📊 **{symbol} Historical Analysis** ({days} days):\n\n"
+            result += f"💲 **Starting Price**: ${first_price:,.2f}\n"
+            result += f"💲 **Current Price**: ${last_price:,.2f}\n"
+            result += f"📊 **Performance**: {performance:+.2f}% {performance_emoji}\n\n"
+            
+            result += f"🔝 **Period High**: ${high_price:,.2f}\n"
+            result += f"🔻 **Period Low**: ${low_price:,.2f}\n"
+            
+            # Calculate volatility (simplified)
+            price_changes = []
+            for i in range(1, len(data_points)):
+                prev_close = data_points[i-1].get("close", 0)
+                curr_close = data_points[i].get("close", 0)
+                if prev_close > 0:
+                    change = abs((curr_close - prev_close) / prev_close) * 100
+                    price_changes.append(change)
+            
+            if price_changes:
+                avg_volatility = sum(price_changes) / len(price_changes)
+                result += f"📈 **Avg Daily Volatility**: {avg_volatility:.2f}%\n"
+            
+            result += f"\n🕒 *Data from CryptoCompare*"
+            return result
+            
+        except Exception as e:
+            logger.error(f"Historical data error: {e}")
+            return f"⚠️ Unable to fetch historical data for {symbol}"
+    
+    async def _get_volume_data(self, symbol: str) -> str:
+        """Get volume and trading data"""
+        try:
+            params = {
+                "fsym": symbol,
+                "tsym": "USD",
+                "extraParams": "Web3ResearchAgent"
+            }
+            
+            if self._api_key:
+                params["api_key"] = self._api_key
+            
+            volume_data = await self.make_request(f"{self._base_url}/pricemultifull", params=params)
+            
+            if not volume_data or "RAW" not in volume_data:
+                return f"❌ No volume data available for {symbol}"
+            
+            raw_data = volume_data["RAW"].get(symbol, {}).get("USD", {})
+            
+            if not raw_data:
+                return f"❌ No trading data found for {symbol}"
+            
+            volume_24h = raw_data.get("VOLUME24HOUR", 0)
+            volume_24h_to = raw_data.get("VOLUME24HOURTO", 0)
+            total_volume = raw_data.get("TOTALVOLUME24H", 0)
+            
+            result = f"📈 **{symbol} Trading Volume**:\n\n"
+            result += f"📊 **24h Volume**: {volume_24h:,.0f} {symbol}\n"
+            result += f"💰 **24h Volume (USD)**: ${volume_24h_to:,.0f}\n"
+            
+            if total_volume > 0:
+                result += f"🌐 **Total 24h Volume**: ${total_volume:,.0f}\n"
+            
+            # Additional trading info
+            open_price = raw_data.get("OPEN24HOUR", 0)
+            high_price = raw_data.get("HIGH24HOUR", 0)
+            low_price = raw_data.get("LOW24HOUR", 0)
+            
+            if open_price > 0:
+                result += f"\n📊 **24h Open**: ${open_price:,.2f}\n"
+                result += f"🔝 **24h High**: ${high_price:,.2f}\n"
+                result += f"🔻 **24h Low**: ${low_price:,.2f}\n"
+            
+            result += f"\n🕒 *Trading data from CryptoCompare*"
+            return result
+            
+        except Exception as e:
+            logger.error(f"Volume data error: {e}")
+            return f"⚠️ Unable to fetch volume data for {symbol}"

src/tools/defillama_tool.py

@@ -2,14 +2,16 @@ 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
+import aiohttp
+import json
 
 logger = get_logger(__name__)
 
 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."""
+    description: str = """Get real DeFi protocol data, TVL, and yields from DeFiLlama API.
+    Useful for: DeFi analysis, protocol rankings, TVL trends, chain analysis.
+    Input: protocol name, chain name, or general DeFi query."""
     args_schema: type[BaseModel] = Web3ToolInput
     
     _base_url: str = PrivateAttr(default="https://api.llama.fi")
@@ -17,151 +19,297 @@ class DeFiLlamaTool(BaseWeb3Tool):
     def __init__(self):
         super().__init__()
     
-    async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None) -> str:
+    async def make_request(self, url: str, timeout: int = 10) -> Optional[Dict[str, Any]]:
+        """Make HTTP request to DeFiLlama API"""
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, timeout=aiohttp.ClientTimeout(total=timeout)) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        logger.info(f"✅ DeFiLlama API call successful: {url}")
+                        return data
+                    else:
+                        logger.error(f"❌ DeFiLlama API error: {response.status} for {url}")
+                        return None
+        except Exception as e:
+            logger.error(f"❌ DeFiLlama API request failed: {e}")
+            return None
+    
+    async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None, **kwargs) -> str:
         try:
             filters = filters or {}
+            query_lower = query.lower()
             
-            if filters.get("type") == "tvl_overview":
-                return await self._get_tvl_overview()
-            elif filters.get("type") == "protocol_data":
+            # Route based on query type
+            if "protocol" in query_lower and any(name in query_lower for name in ["uniswap", "aave", "compound", "curve"]):
                 return await self._get_protocol_data(query)
-            elif query:
-                return await self._search_protocols(query)
-            else:
+            elif any(word in query_lower for word in ["chain", "ethereum", "polygon", "avalanche", "bsc"]):
+                return await self._get_chain_tvl(query)
+            elif "tvl" in query_lower or "total value locked" in query_lower:
+                return await self._get_tvl_overview()
+            elif "top" in query_lower or "ranking" in query_lower:
                 return await self._get_top_protocols()
+            else:
+                return await self._search_protocols(query)
                 
         except Exception as e:
             logger.error(f"DeFiLlama error: {e}")
             return f"⚠️ DeFiLlama service temporarily unavailable: {str(e)}"
     
     async def _get_top_protocols(self) -> str:
+        """Get top protocols using /protocols endpoint"""
         try:
             data = await self.make_request(f"{self._base_url}/protocols")
             
             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
+            # Sort by TVL and take top 10
+            top_protocols = sorted([p for p in data if p.get("tvl") is not None and p.get("tvl", 0) > 0], 
+                                 key=lambda x: x.get("tvl", 0), reverse=True)[:10]
             
-            if not valid_protocols:
+            if not top_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"
+                name = protocol.get("name", "Unknown")
+                tvl = protocol.get("tvl", 0)
+                change_1d = protocol.get("change_1d", 0)
+                chain = protocol.get("chain", "Multi-chain")
+                
+                emoji = "📈" if change_1d >= 0 else "📉"
+                tvl_formatted = f"${tvl/1e9:.2f}B" if tvl >= 1e9 else f"${tvl/1e6:.1f}M"
+                change_formatted = f"({change_1d:+.2f}%)" if change_1d is not None else "(N/A)"
+                
+                result += f"{i}. **{name}** ({chain}): {tvl_formatted} TVL {emoji} {change_formatted}\n"
+            
+            return result
             
         except Exception as e:
             logger.error(f"Top protocols error: {e}")
             return "⚠️ DeFi protocol data temporarily unavailable"
+
+    async def _get_protocol_data(self, protocol_name: str) -> str:
+        """Get specific protocol data using /protocol/{protocol} endpoint"""
+        try:
+            # First get all protocols to find the slug
+            protocols = await self.make_request(f"{self._base_url}/protocols")
+            if not protocols:
+                return f"❌ Cannot fetch protocols list"
+            
+            # Find matching protocol
+            matching_protocol = None
+            for p in protocols:
+                if protocol_name.lower() in p.get("name", "").lower():
+                    matching_protocol = p
+                    break
+            
+            if not matching_protocol:
+                return f"❌ Protocol '{protocol_name}' not found"
+            
+            # Get detailed protocol data
+            protocol_slug = matching_protocol.get("slug", protocol_name.lower())
+            detailed_data = await self.make_request(f"{self._base_url}/protocol/{protocol_slug}")
+            
+            if detailed_data:
+                # Use detailed data if available
+                name = detailed_data.get("name", matching_protocol.get("name"))
+                tvl = detailed_data.get("tvl", matching_protocol.get("tvl", 0))
+                change_1d = detailed_data.get("change_1d", matching_protocol.get("change_1d", 0))
+                change_7d = detailed_data.get("change_7d", matching_protocol.get("change_7d", 0))
+                chains = detailed_data.get("chains", [matching_protocol.get("chain", "Unknown")])
+                category = detailed_data.get("category", matching_protocol.get("category", "Unknown"))
+                description = detailed_data.get("description", "No description available")
+            else:
+                # Fallback to basic protocol data
+                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)
+                chains = [matching_protocol.get("chain", "Unknown")]
+                category = matching_protocol.get("category", "Unknown")
+                description = "No description available"
+            
+            result = f"🏛️ **{name} Protocol Analysis:**\n\n"
+            result += f"📝 **Description**: {description[:200]}{'...' if len(description) > 200 else ''}\n\n"
+            result += f"💰 **Current TVL**: ${tvl/1e9:.2f}B\n"
+            result += f"📊 **24h Change**: {change_1d:+.2f}%\n"
+            result += f"📈 **7d Change**: {change_7d:+.2f}%\n"
+            result += f"⛓️ **Chains**: {', '.join(chains) if isinstance(chains, list) else str(chains)}\n"
+            result += f"🏷️ **Category**: {category}\n"
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Protocol data error: {e}")
+            return f"⚠️ Error fetching data for {protocol_name}: {str(e)}"
     
     async def _get_tvl_overview(self) -> str:
+        """Get TVL overview using /protocols and /v2/chains endpoints"""
         try:
-            protocols_data = await self.make_request(f"{self.base_url}/protocols")
-            chains_data = await self.make_request(f"{self.base_url}/chains")
+            # Get protocols and chains data
+            protocols_data = await self.make_request(f"{self._base_url}/protocols")
+            chains_data = await self.make_request(f"{self._base_url}/v2/chains")
             
-            if not protocols_data or not chains_data:
-                return "TVL overview data unavailable"
+            if not protocols_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]
+            # Calculate total TVL
+            total_tvl = sum(p.get("tvl", 0) for p in protocols_data if p.get("tvl") is not None and p.get("tvl", 0) > 0)
             
             result = "🌐 **DeFi TVL Overview:**\n\n"
-            result += f"💰 **Total TVL**: ${total_tvl/1e9:.2f}B\n\n"
-            result += "**Top Chains by TVL:**\n"
+            result += f"💰 **Total DeFi TVL**: ${total_tvl/1e9:.2f}B\n\n"
+            
+            # Add chain data if available
+            if chains_data and isinstance(chains_data, list):
+                top_chains = sorted([c for c in chains_data if c.get("tvl") is not None and c.get("tvl", 0) > 0], 
+                                  key=lambda x: x.get("tvl", 0), reverse=True)[:5]
+                
+                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"
+            
+            # Add top protocol categories
+            categories = {}
+            for protocol in protocols_data:
+                if protocol.get("tvl") is not None and protocol.get("tvl", 0) > 0:
+                    category = protocol.get("category", "Other")
+                    categories[category] = categories.get(category, 0) + protocol.get("tvl", 0)
             
-            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"
+            if categories:
+                result += "\n**Top Categories by TVL:**\n"
+                sorted_categories = sorted(categories.items(), key=lambda x: x[1], reverse=True)[:5]
+                for i, (category, tvl) in enumerate(sorted_categories, 1):
+                    result += f"{i}. **{category}**: ${tvl/1e9:.2f}B\n"
             
             return result
             
-        except Exception:
+        except Exception as e:
+            logger.error(f"TVL overview error: {e}")
             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 _get_chain_tvl(self, chain_query: str) -> str:
+        """Get chain TVL data using /v2/historicalChainTvl/{chain} endpoint"""
+        try:
+            # Map common chain names
+            chain_mapping = {
+                "ethereum": "Ethereum",
+                "eth": "Ethereum", 
+                "polygon": "Polygon",
+                "matic": "Polygon",
+                "bsc": "BSC",
+                "binance": "BSC",
+                "avalanche": "Avalanche",
+                "avax": "Avalanche",
+                "arbitrum": "Arbitrum",
+                "optimism": "Optimism",
+                "fantom": "Fantom",
+                "solana": "Solana",
+                "sol": "Solana"
+            }
+            
+            # Extract chain name from query
+            chain_name = None
+            for key, value in chain_mapping.items():
+                if key in chain_query.lower():
+                    chain_name = value
+                    break
+            
+            if not chain_name:
+                # Try to get all chains first
+                chains_data = await self.make_request(f"{self._base_url}/v2/chains")
+                if chains_data:
+                    result = "⛓️ **Available Chains:**\n\n"
+                    sorted_chains = sorted([c for c in chains_data if c.get("tvl", 0) > 0], 
+                                         key=lambda x: x.get("tvl", 0), reverse=True)[:10]
+                    for i, chain in enumerate(sorted_chains, 1):
+                        name = chain.get("name", "Unknown")
+                        tvl = chain.get("tvl", 0)
+                        result += f"{i}. **{name}**: ${tvl/1e9:.2f}B TVL\n"
+                    return result
+                else:
+                    return f"❌ Chain '{chain_query}' not recognized. Try: ethereum, polygon, bsc, avalanche, etc."
+            
+            # Get historical TVL for the chain
+            historical_data = await self.make_request(f"{self._base_url}/v2/historicalChainTvl/{chain_name}")
+            
+            if not historical_data:
+                return f"❌ No data available for {chain_name}"
+            
+            # Get current TVL (last entry)
+            current_tvl = historical_data[-1]["tvl"] if historical_data else 0
+            
+            result = f"⛓️ **{chain_name} Chain Analysis:**\n\n"
+            result += f"💰 **Current TVL**: ${current_tvl/1e9:.2f}B\n"
+            
+            # Calculate changes if we have enough data
+            if len(historical_data) >= 2:
+                prev_tvl = historical_data[-2]["tvl"]
+                daily_change = ((current_tvl - prev_tvl) / prev_tvl) * 100 if prev_tvl > 0 else 0
+                emoji = "📈" if daily_change >= 0 else "📉"
+                result += f"� **24h Change**: {daily_change:+.2f}% {emoji}\n"
+            
+            if len(historical_data) >= 7:
+                week_ago_tvl = historical_data[-7]["tvl"]
+                weekly_change = ((current_tvl - week_ago_tvl) / week_ago_tvl) * 100 if week_ago_tvl > 0 else 0
+                emoji = "📈" if weekly_change >= 0 else "📉"
+                result += f"📈 **7d Change**: {weekly_change:+.2f}% {emoji}\n"
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Chain TVL error: {e}")
+            return f"⚠️ Error fetching chain data: {str(e)}"
     
     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
+        """Search protocols by name"""
+        try:
+            protocols = await self.make_request(f"{self._base_url}/protocols")
+            
+            if not protocols:
+                return "⚠️ No protocol data available"
+            
+            # Search for matching protocols
+            query_lower = query.lower()
+            matching = []
+            
+            for p in protocols:
+                name = p.get("name", "").lower()
+                category = p.get("category", "").lower() 
+                
+                if (query_lower in name or 
+                    query_lower in category or
+                    any(word in name for word in query_lower.split())):
+                    matching.append(p)
+            
+            # Sort by TVL and limit results 
+            matching = sorted([p for p in matching if p.get("tvl") is not None and p.get("tvl", 0) > 0], 
+                            key=lambda x: x.get("tvl", 0), reverse=True)[:8]
+            
+            if not matching:
+                return f"❌ No protocols found matching '{query}'"
+            
+            result = f"🔍 **Protocols matching '{query}':**\n\n"
+            
+            for i, protocol in enumerate(matching, 1):
+                name = protocol.get("name", "Unknown")
+                tvl = protocol.get("tvl", 0)
+                chain = protocol.get("chain", "Multi-chain")
+                category = protocol.get("category", "Unknown")
+                change_1d = protocol.get("change_1d", 0)
+                
+                emoji = "📈" if change_1d >= 0 else "📉"
+                tvl_formatted = f"${tvl/1e9:.2f}B" if tvl >= 1e9 else f"${tvl/1e6:.1f}M"
+                
+                result += f"{i}. **{name}** ({category})\n"
+                result += f"   💰 {tvl_formatted} TVL on {chain} {emoji} {change_1d:+.1f}%\n\n"
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Search protocols error: {e}")
+            return f"⚠️ Search temporarily unavailable: {str(e)}"

src/tools/etherscan_tool.py

@@ -25,7 +25,7 @@ class EtherscanTool(BaseWeb3Tool):
         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:
+    async def _arun(self, query: str, filters: Optional[Dict[str, Any]] = None, **kwargs) -> str:
         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`"
         

src/utils/ai_safety.py

@@ -0,0 +1,192 @@
+"""
+AI Safety Module for Ollama Integration
+Implements content filtering, prompt sanitization, and safety guardrails
+"""
+
+import re
+import logging
+from typing import Dict, List, Tuple, Optional, Any
+from datetime import datetime, timedelta
+
+logger = logging.getLogger(__name__)
+
+class AISafetyGuard:
+    """AI Safety guardrails for Ollama interactions"""
+    
+    def __init__(self):
+        self.blocked_patterns = self._load_blocked_patterns()
+        self.request_history = []
+        self.max_requests_per_minute = 10
+        self.max_query_length = 2000
+        
+    def _load_blocked_patterns(self) -> List[str]:
+        """Load patterns that should be blocked for safety"""
+        return [
+            # Malicious patterns
+            r'(?i)hack|exploit|vulnerability|backdoor|malware',
+            r'(?i)bypass.*security|override.*safety|disable.*filter',
+            r'(?i)jailbreak|prompt.*injection|ignore.*instructions',
+            
+            # Financial manipulation
+            r'(?i)pump.*dump|market.*manipulation|insider.*trading',
+            r'(?i)fake.*price|manipulate.*market|artificial.*inflation',
+            
+            # Personal data requests
+            r'(?i)private.*key|wallet.*seed|password|personal.*data',
+            r'(?i)social.*security|credit.*card|bank.*account',
+            
+            # Harmful content
+            r'(?i)illegal.*activity|money.*laundering|tax.*evasion',
+            r'(?i)terrorist.*financing|sanctions.*evasion',
+            
+            # System manipulation
+            r'(?i)system.*prompt|role.*play.*as|pretend.*to.*be',
+            r'(?i)act.*as.*if|simulate.*being|become.*character',
+        ]
+    
+    def sanitize_query(self, query: str) -> Tuple[str, bool, str]:
+        """
+        Sanitize user query for safety
+        Returns: (sanitized_query, is_safe, reason)
+        """
+        if not query or not query.strip():
+            return "", False, "Empty query"
+        
+        # Check query length
+        if len(query) > self.max_query_length:
+            return "", False, f"Query too long ({len(query)} chars, max {self.max_query_length})"
+        
+        # Check for blocked patterns
+        for pattern in self.blocked_patterns:
+            if re.search(pattern, query):
+                logger.warning(f"Blocked unsafe query pattern: {pattern}")
+                return "", False, "Query contains potentially unsafe content"
+        
+        # Basic sanitization
+        sanitized = query.strip()
+        sanitized = re.sub(r'[<>]', '', sanitized)  # Remove HTML brackets
+        sanitized = re.sub(r'\s+', ' ', sanitized)  # Normalize whitespace
+        
+        return sanitized, True, "Query is safe"
+    
+    def check_rate_limit(self, user_id: str = "default") -> Tuple[bool, str]:
+        """Check if request rate limit is exceeded"""
+        current_time = datetime.now()
+        
+        # Clean old requests (older than 1 minute)
+        self.request_history = [
+            req for req in self.request_history 
+            if current_time - req['timestamp'] < timedelta(minutes=1)
+        ]
+        
+        # Count requests from this user in the last minute
+        user_requests = [
+            req for req in self.request_history 
+            if req['user_id'] == user_id
+        ]
+        
+        if len(user_requests) >= self.max_requests_per_minute:
+            return False, f"Rate limit exceeded: {len(user_requests)}/{self.max_requests_per_minute} requests per minute"
+        
+        # Add current request
+        self.request_history.append({
+            'user_id': user_id,
+            'timestamp': current_time
+        })
+        
+        return True, "Rate limit OK"
+    
+    def validate_ollama_response(self, response: str) -> Tuple[str, bool, str]:
+        """
+        Validate Ollama response for safety and quality
+        Returns: (cleaned_response, is_valid, reason)
+        """
+        if not response or not response.strip():
+            return "", False, "Empty response from Ollama"
+        
+        # Check for dangerous content in response
+        dangerous_patterns = [
+            r'(?i)here.*is.*how.*to.*hack',
+            r'(?i)steps.*to.*exploit',
+            r'(?i)bypass.*security.*by',
+            r'(?i)manipulate.*market.*by',
+        ]
+        
+        for pattern in dangerous_patterns:
+            if re.search(pattern, response):
+                logger.warning(f"Blocked unsafe Ollama response: {pattern}")
+                return "", False, "Response contains potentially unsafe content"
+        
+        # Basic response cleaning
+        cleaned = response.strip()
+        
+        # Remove any potential HTML/JavaScript
+        cleaned = re.sub(r'<script.*?</script>', '', cleaned, flags=re.DOTALL | re.IGNORECASE)
+        cleaned = re.sub(r'<[^>]+>', '', cleaned)
+        
+        # Ensure response is within reasonable length
+        if len(cleaned) > 10000:  # 10k character limit
+            cleaned = cleaned[:10000] + "\n\n[Response truncated for safety]"
+        
+        return cleaned, True, "Response is safe"
+    
+    def validate_gemini_response(self, response: str) -> Tuple[str, bool, str]:
+        """
+        Validate Gemini response for safety and quality
+        Returns: (cleaned_response, is_valid, reason)
+        """
+        if not response or not response.strip():
+            return "", False, "Empty response from Gemini"
+        
+        # Check for dangerous content in response
+        dangerous_patterns = [
+            r'(?i)here.*is.*how.*to.*hack',
+            r'(?i)steps.*to.*exploit',
+            r'(?i)bypass.*security.*by',
+            r'(?i)manipulate.*market.*by',
+        ]
+        
+        for pattern in dangerous_patterns:
+            if re.search(pattern, response):
+                logger.warning(f"Blocked unsafe Gemini response: {pattern}")
+                return "", False, "Response contains potentially unsafe content"
+        
+        # Basic response cleaning
+        cleaned = response.strip()
+        
+        # Remove any potential HTML/JavaScript
+        cleaned = re.sub(r'<script.*?</script>', '', cleaned, flags=re.DOTALL | re.IGNORECASE)
+        cleaned = re.sub(r'<[^>]+>', '', cleaned)
+        
+        # Ensure response is within reasonable length
+        if len(cleaned) > 10000:  # 10k character limit
+            cleaned = cleaned[:10000] + "\n\n[Response truncated for safety]"
+        
+        return cleaned, True, "Response is safe"
+    
+    def create_safe_prompt(self, user_query: str, tool_context: str) -> str:
+        """Create a safety-enhanced prompt for Ollama - Optimized for speed"""
+        
+        # Truncate context if too long to improve processing speed
+        if len(tool_context) > 2000:
+            tool_context = tool_context[:2000] + "\n[Context truncated for processing speed]"
+        
+        prompt = f"""Answer this cryptocurrency question using the data provided:
+
+QUESTION: {user_query}
+
+DATA:
+{tool_context}
+
+Provide a helpful, factual response focused on cryptocurrency analysis. Be concise and professional.
+
+ANSWER:"""
+        
+        return prompt
+    
+    def log_safety_event(self, event_type: str, details: Dict[str, Any]):
+        """Log safety-related events for monitoring"""
+        logger.info(f"AI Safety Event: {event_type} - {details}")
+
+# Global safety instance
+ai_safety = AISafetyGuard()

src/utils/config.py

@@ -8,10 +8,19 @@ 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", "")
+    # LLM Configuration - Both Ollama and Gemini available
+    GEMINI_API_KEY: str = os.getenv("GEMINI_API_KEY", "")  # Enable Gemini when API key provided
+    USE_OLLAMA_ONLY: bool = not bool(os.getenv("GEMINI_API_KEY"))  # Auto-detect based on API key
+    
+    # Available API Keys
+    COINGECKO_API_KEY: Optional[str] = None  # Not available - costs money
+    CRYPTOCOMPARE_API_KEY: Optional[str] = os.getenv("CRYPTOCOMPARE_API_KEY")  # Available
+    ETHERSCAN_API_KEY: str = os.getenv("ETHERSCAN_API_KEY", "")  # Available
+    
+    # Ollama Configuration
+    OLLAMA_BASE_URL: str = "http://localhost:11434"
+    OLLAMA_MODEL: str = "llama3.1:8b"  # Upgraded to Llama 3.1 8B for HF Spaces with 16GB RAM
+    USE_OLLAMA_FALLBACK: bool = True
     
     COINGECKO_BASE_URL: str = "https://api.coingecko.com/api/v3"
     CRYPTOCOMPARE_BASE_URL: str = "https://min-api.cryptocompare.com/data"

static/app.js

@@ -0,0 +1,387 @@
+let chatHistory = [];
+let messageCount = 0;
+let useGemini = false; // Track current LLM choice
+
+// Initialize Gemini toggle
+document.addEventListener('DOMContentLoaded', function() {
+    const geminiToggle = document.getElementById('geminiToggle');
+    const toggleLabel = document.querySelector('.toggle-label');
+    
+    // Load saved preference
+    useGemini = localStorage.getItem('useGemini') === 'true';
+    geminiToggle.checked = useGemini;
+    updateToggleLabel();
+    
+    // Handle toggle changes
+    geminiToggle.addEventListener('change', function() {
+        useGemini = this.checked;
+        localStorage.setItem('useGemini', useGemini.toString());
+        updateToggleLabel();
+        console.log(`Switched to ${useGemini ? 'Gemini' : 'Ollama'} mode`);
+        
+        // Show confirmation
+        showStatus(`Switched to ${useGemini ? 'Gemini (Cloud AI)' : 'Ollama (Local AI)'} mode`, 'info');
+        
+        // Refresh status to reflect changes
+        checkStatus();
+    });
+});
+
+function updateToggleLabel() {
+    const toggleLabel = document.querySelector('.toggle-label');
+    if (toggleLabel) {
+        toggleLabel.textContent = `AI Model: ${useGemini ? 'Gemini' : 'Ollama'}`;
+    }
+}
+
+async function checkStatus() {
+    try {
+        const response = await fetch('/status');
+        const status = await response.json();
+        
+        const statusDiv = document.getElementById('status');
+        
+        if (status.enabled && status.gemini_configured) {
+            statusDiv.className = 'status online';
+            statusDiv.innerHTML = '<span>Research systems online</span>' +
+                '<div style="margin-top: 0.5rem; font-size: 0.85rem; opacity: 0.8;">' +
+                'Tools: ' + status.tools_available.join(' • ') + '</div>';
+        } else {
+            statusDiv.className = 'status offline';
+            statusDiv.innerHTML = '<span>Limited mode - Configure GEMINI_API_KEY for full functionality</span>' +
+                '<div style="margin-top: 0.5rem; font-size: 0.85rem; opacity: 0.8;">' +
+                'Available: ' + status.tools_available.join(' • ') + '</div>';
+        }
+    } catch (error) {
+        const statusDiv = document.getElementById('status');
+        statusDiv.className = 'status offline';
+        statusDiv.innerHTML = '<span>Connection error</span>';
+    }
+}
+
+async function sendQuery() {
+    const input = document.getElementById('queryInput');
+    const sendBtn = document.getElementById('sendBtn');
+    const loadingIndicator = document.getElementById('loadingIndicator');
+    const statusIndicator = document.getElementById('statusIndicator');
+    const statusText = document.getElementById('statusText');
+    const query = input.value.trim();
+
+    if (!query) {
+        showStatus('Please enter a research query', 'warning');
+        return;
+    }
+
+    console.log('Sending research query');
+    addMessage('user', query);
+    input.value = '';
+
+    // Update UI states
+    sendBtn.disabled = true;
+    sendBtn.innerHTML = '<span class="loading">Processing</span>';
+    loadingIndicator.classList.add('active');
+    showStatus('Initializing research...', 'processing');
+
+    try {
+        console.log('Starting streaming API request...');
+        const requestStart = Date.now();
+        
+        // Create an AbortController for manual timeout control
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+            console.log('Manual timeout after 5 minutes');
+            controller.abort();
+        }, 300000); // 5 minute timeout instead of default browser timeout
+        
+        // Use fetch with streaming for POST requests with body
+        const response = await fetch('/query/stream', {
+            method: 'POST',
+            headers: { 
+                'Content-Type': 'application/json',
+                'Accept': 'text/event-stream',
+                'Cache-Control': 'no-cache'
+            },
+            body: JSON.stringify({ 
+                query, 
+                chat_history: chatHistory, 
+                use_gemini: useGemini 
+            }),
+            signal: controller.signal,
+            // Disable browser's default timeout behavior
+            keepalive: true
+        });
+
+        // Clear the timeout since we got a response
+        clearTimeout(timeoutId);
+
+        if (!response.ok) {
+            throw new Error('Request failed with status ' + response.status);
+        }
+
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop(); // Keep incomplete line in buffer
+
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    try {
+                        const data = JSON.parse(line.substring(6));
+                        
+                        if (data.type === 'status') {
+                            showStatus(data.message, 'processing');
+                            updateProgress(data.progress);
+                            // Also update the loading text
+                            const loadingText = document.getElementById('loadingText');
+                            if (loadingText) {
+                                loadingText.textContent = data.message;
+                            }
+                            console.log('Progress: ' + data.progress + '% - ' + data.message);
+                        } else if (data.type === 'tools') {
+                            showStatus(data.message, 'processing');
+                            // Update loading text for tools
+                            const loadingText = document.getElementById('loadingText');
+                            if (loadingText) {
+                                loadingText.textContent = data.message;
+                            }
+                            console.log('Tools: ' + data.message);
+                        } else if (data.type === 'result') {
+                            const result = data.data;
+                            const requestTime = Date.now() - requestStart;
+                            console.log('Request completed in ' + requestTime + 'ms');
+                            
+                            if (result.success) {
+                                addMessage('assistant', result.response, result.sources, result.visualizations);
+                                showStatus('Research complete', 'success');
+                                console.log('Analysis completed successfully');
+                            } else {
+                                console.log('Analysis request failed');
+                                addMessage('assistant', result.response || 'Analysis temporarily unavailable. Please try again.', [], []);
+                                showStatus('Request failed', 'error');
+                            }
+                        } else if (data.type === 'complete') {
+                            break;
+                        } else if (data.type === 'error') {
+                            throw new Error(data.message);
+                        }
+                    } catch (parseError) {
+                        console.error('Parse error:', parseError);
+                    }
+                }
+            }
+        }
+
+    } catch (error) {
+        console.error('Streaming request error:', error);
+        
+        // More specific error handling
+        if (error.name === 'AbortError') {
+            addMessage('assistant', 'Request timed out after 5 minutes. Ollama may be processing a complex query. Please try a simpler question or wait and try again.');
+            showStatus('Request timed out', 'error');
+        } else if (error.message.includes('Failed to fetch') || error.message.includes('network error')) {
+            addMessage('assistant', 'Network connection error. Please check your internet connection and try again.');
+            showStatus('Connection error', 'error');
+        } else if (error.message.includes('ERR_HTTP2_PROTOCOL_ERROR')) {
+            addMessage('assistant', 'Ollama is still processing your request in the background. Please wait a moment and try again, or try a simpler query.');
+            showStatus('Processing - please retry', 'warning');
+        } else {
+            addMessage('assistant', 'Connection error. Please check your network and try again.');
+            showStatus('Connection error', 'error');
+        }
+    } finally {
+        // Reset UI states
+        sendBtn.disabled = false;
+        sendBtn.innerHTML = 'Research';
+        loadingIndicator.classList.remove('active');
+        input.focus();
+        console.log('Request completed');
+        
+        // Hide status after delay
+        setTimeout(() => hideStatus(), 3000);
+    }
+}
+
+function addMessage(sender, content, sources = [], visualizations = []) {
+    const messagesDiv = document.getElementById('chatMessages');
+    
+    // Clear welcome message
+    if (messageCount === 0) {
+        messagesDiv.innerHTML = '';
+    }
+    messageCount++;
+
+    const messageDiv = document.createElement('div');
+    messageDiv.className = 'message ' + sender;
+
+    let sourcesHtml = '';
+    if (sources && sources.length > 0) {
+        sourcesHtml = `
+            <div class="sources">
+                Sources: ${sources.map(s => `<span>${s}</span>`).join('')}
+            </div>
+        `;
+    }
+
+    let visualizationHtml = '';
+    if (visualizations && visualizations.length > 0) {
+        console.log('Processing visualizations:', visualizations.length);
+        visualizationHtml = visualizations.map((viz, index) => {
+            console.log(`Visualization ${index}:`, viz.substring(0, 100));
+            return `<div class="visualization-container" id="viz-${Date.now()}-${index}">${viz}</div>`;
+        }).join('');
+    }
+
+    // Format content based on sender
+    let formattedContent = content;
+    if (sender === 'assistant') {
+        // Convert markdown to HTML for assistant responses
+        try {
+            formattedContent = marked.parse(content);
+        } catch (error) {
+            // Fallback to basic formatting if marked.js fails
+            console.warn('Markdown parsing failed, using fallback:', error);
+            formattedContent = content
+                .replace(/\n/g, '<br>')
+                .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+                .replace(/\*(.*?)\*/g, '<em>$1</em>')
+                .replace(/`(.*?)`/g, '<code>$1</code>');
+        }
+    } else {
+        // Apply markdown parsing to user messages too
+        try {
+            formattedContent = marked.parse(content);
+        } catch (error) {
+            formattedContent = content.replace(/\n/g, '<br>');
+        }
+    }
+
+    messageDiv.innerHTML = `
+        <div class="message-content">
+            ${formattedContent}
+            ${sourcesHtml}
+        </div>
+        ${visualizationHtml}
+        <div class="message-meta">${new Date().toLocaleTimeString()}</div>
+    `;
+
+    messagesDiv.appendChild(messageDiv);
+    messagesDiv.scrollTop = messagesDiv.scrollHeight;
+
+    // Execute any scripts in the visualizations after DOM insertion
+    if (visualizations && visualizations.length > 0) {
+        console.log('Executing visualization scripts...');
+        setTimeout(() => {
+            const scripts = messageDiv.querySelectorAll('script');
+            console.log(`Found ${scripts.length} scripts to execute`);
+            
+            scripts.forEach((script, index) => {
+                console.log(`Executing script ${index}:`, script.textContent.substring(0, 200) + '...');
+                try {
+                    // Execute script in global context using Function constructor
+                    const scriptFunction = new Function(script.textContent);
+                    scriptFunction.call(window);
+                    console.log(`Script ${index} executed successfully`);
+                } catch (error) {
+                    console.error(`Script ${index} execution error:`, error);
+                    console.error(`Script content preview:`, script.textContent.substring(0, 500));
+                }
+            });
+            console.log('All visualization scripts executed');
+        }, 100);
+    }
+
+    chatHistory.push({ role: sender, content });
+    if (chatHistory.length > 20) chatHistory = chatHistory.slice(-20);
+}
+
+function setQuery(query) {
+    document.getElementById('queryInput').value = query;
+    setTimeout(() => sendQuery(), 100);
+}
+
+// Status management functions
+function showStatus(message, type = 'info') {
+    const statusIndicator = document.getElementById('statusIndicator');
+    const statusText = document.getElementById('statusText');
+    
+    statusText.textContent = message;
+    statusIndicator.className = `status-indicator show ${type}`;
+}
+
+function hideStatus() {
+    const statusIndicator = document.getElementById('statusIndicator');
+    statusIndicator.classList.remove('show');
+}
+
+function updateProgress(progress) {
+    // Update progress bar if it exists
+    const progressBar = document.querySelector('.progress-bar');
+    if (progressBar) {
+        progressBar.style.width = `${progress}%`;
+    }
+    
+    // Update loading indicator text with progress
+    const loadingText = document.getElementById('loadingText');
+    if (loadingText && progress) {
+        loadingText.textContent = `Processing ${progress}%...`;
+    }
+}
+
+// Theme toggle functionality
+function toggleTheme() {
+    const currentTheme = document.documentElement.getAttribute('data-theme');
+    const newTheme = currentTheme === 'light' ? 'dark' : 'light';
+    const themeIcon = document.querySelector('#themeToggle i');
+    
+    document.documentElement.setAttribute('data-theme', newTheme);
+    localStorage.setItem('theme', newTheme);
+    
+    // Update icon
+    if (newTheme === 'light') {
+        themeIcon.className = 'fas fa-sun';
+    } else {
+        themeIcon.className = 'fas fa-moon';
+    }
+}
+
+// Initialize theme
+function initializeTheme() {
+    const savedTheme = localStorage.getItem('theme') || 'dark';
+    const themeIcon = document.querySelector('#themeToggle i');
+    
+    document.documentElement.setAttribute('data-theme', savedTheme);
+    
+    if (savedTheme === 'light') {
+        themeIcon.className = 'fas fa-sun';
+    } else {
+        themeIcon.className = 'fas fa-moon';
+    }
+}
+
+// Event listeners
+document.getElementById('queryInput').addEventListener('keypress', (e) => {
+    if (e.key === 'Enter') sendQuery();
+});
+
+document.getElementById('sendBtn').addEventListener('click', (e) => {
+    console.log('Research button clicked');
+    e.preventDefault();
+    sendQuery();
+});
+
+document.getElementById('themeToggle').addEventListener('click', toggleTheme);
+
+// Initialize
+document.addEventListener('DOMContentLoaded', () => {
+    console.log('Application initialized');
+    initializeTheme();
+    checkStatus();
+    document.getElementById('queryInput').focus();
+});

static/styles.css

@@ -0,0 +1,767 @@
+:root {
+    --primary: #0066ff;
+    --primary-dark: #0052cc;
+    --accent: #00d4aa;
+    --background: #000000;
+    --surface: #111111;
+    --surface-elevated: #1a1a1a;
+    --text: #ffffff;
+    --text-secondary: #a0a0a0;
+    --text-muted: #666666;
+    --border: rgba(255, 255, 255, 0.08);
+    --border-focus: rgba(0, 102, 255, 0.3);
+    --shadow: rgba(0, 0, 0, 0.4);
+    --success: #00d4aa;
+    --warning: #ffa726;
+    --error: #f44336;
+}
+
+[data-theme="light"] {
+    --background: #ffffff;
+    --surface: #f8f9fa;
+    --surface-elevated: #ffffff;
+    --text: #1a1a1a;
+    --text-secondary: #4a5568;
+    --text-muted: #718096;
+    --border: rgba(0, 0, 0, 0.08);
+    --border-focus: rgba(0, 102, 255, 0.3);
+    --shadow: rgba(0, 0, 0, 0.1);
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+    transition: background-color 0.3s ease, color 0.3s ease, border-color 0.3s ease;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, sans-serif;
+    background: var(--background);
+    color: var(--text);
+    line-height: 1.5;
+    min-height: 100vh;
+    font-weight: 400;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+}
+
+.container {
+    max-width: 1000px;
+    margin: 0 auto;
+    padding: 2rem 1.5rem;
+}
+
+.header {
+    text-align: center;
+    margin-bottom: 2.5rem;
+}
+.header-content {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    max-width: 100%;
+}
+.header-text {
+    flex: 1;
+    text-align: center;
+}
+.header-controls {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+}
+
+/* LLM Toggle Switch Styles */
+.llm-toggle {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+.toggle-label {
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+.switch {
+    position: relative;
+    display: inline-block;
+    width: 80px;
+    height: 32px;
+}
+
+.switch input {
+    opacity: 0;
+    width: 0;
+    height: 0;
+}
+
+.slider {
+    position: absolute;
+    cursor: pointer;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background-color: var(--surface);
+    border: 1px solid var(--border);
+    transition: .4s;
+    overflow: hidden;
+}
+
+.slider:before {
+    position: absolute;
+    content: "";
+    height: 24px;
+    width: 24px;
+    left: 3px;
+    bottom: 3px;
+    background-color: var(--primary);
+    transition: .4s;
+    border-radius: 50%;
+    z-index: 2;
+}
+
+.slider-text-off, .slider-text-on {
+    position: absolute;
+    color: var(--text-secondary);
+    font-size: 0.7rem;
+    font-weight: 500;
+    top: 50%;
+    transform: translateY(-50%);
+    transition: .4s;
+    pointer-events: none;
+    z-index: 1;
+}
+
+.slider-text-off {
+    left: 8px;
+}
+
+.slider-text-on {
+    right: 8px;
+    opacity: 0;
+}
+
+input:checked + .slider {
+    background-color: var(--accent);
+    border-color: var(--accent);
+}
+
+input:checked + .slider .slider-text-off {
+    opacity: 0;
+}
+
+input:checked + .slider .slider-text-on {
+    opacity: 1;
+}
+
+input:checked + .slider:before {
+    transform: translateX(48px);
+}
+
+.slider.round {
+    border-radius: 20px;
+}
+
+.slider.round:before {
+    border-radius: 50%;
+}
+
+.theme-toggle {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 0.75rem;
+    color: var(--text);
+    cursor: pointer;
+    transition: all 0.2s ease;
+    font-size: 1.1rem;
+    min-width: 44px;
+    height: 44px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+.theme-toggle:hover {
+    background: var(--surface-elevated);
+    border-color: var(--primary);
+    transform: translateY(-1px);
+}
+
+.header h1 {
+    font-size: 2.25rem;
+    font-weight: 600;
+    color: var(--text);
+    margin-bottom: 0.5rem;
+    letter-spacing: -0.025em;
+}
+
+.header .brand {
+    color: var(--primary);
+}
+
+.header p {
+    color: var(--text-secondary);
+    font-size: 1rem;
+    font-weight: 400;
+}
+
+.status {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 12px;
+    padding: 1rem 1.5rem;
+    margin-bottom: 2rem;
+    text-align: center;
+    transition: all 0.2s ease;
+}
+
+.status.online {
+    border-color: var(--success);
+    background: linear-gradient(135deg, rgba(0, 212, 170, 0.05), rgba(0, 212, 170, 0.02));
+}
+
+.status.offline {
+    border-color: var(--error);
+    background: linear-gradient(135deg, rgba(244, 67, 54, 0.05), rgba(244, 67, 54, 0.02));
+}
+
+.status.checking {
+    border-color: var(--warning);
+    background: linear-gradient(135deg, rgba(255, 167, 38, 0.05), rgba(255, 167, 38, 0.02));
+    animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.8; }
+}
+
+.chat-interface {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 16px;
+    overflow: hidden;
+    margin-bottom: 2rem;
+    backdrop-filter: blur(20px);
+}
+
+.chat-messages {
+    height: 480px;
+    overflow-y: auto;
+    padding: 2rem;
+    background: linear-gradient(180deg, var(--background), var(--surface));
+}
+
+.chat-messages::-webkit-scrollbar {
+    width: 3px;
+}
+
+.chat-messages::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+.chat-messages::-webkit-scrollbar-thumb {
+    background: var(--border);
+    border-radius: 2px;
+}
+
+.message {
+    margin-bottom: 2rem;
+    opacity: 0;
+    animation: messageSlide 0.4s cubic-bezier(0.2, 0, 0.2, 1) forwards;
+}
+
+@keyframes messageSlide {
+    from { 
+        opacity: 0; 
+        transform: translateY(20px) scale(0.98); 
+    }
+    to { 
+        opacity: 1; 
+        transform: translateY(0) scale(1); 
+    }
+}
+
+.message.user {
+    text-align: right;
+}
+
+.message.assistant {
+    text-align: left;
+}
+
+.message-content {
+    display: inline-block;
+    max-width: 75%;
+    padding: 1.25rem 1.5rem;
+    border-radius: 24px;
+    font-size: 0.95rem;
+    line-height: 1.6;
+    position: relative;
+}
+
+.message.user .message-content {
+    background: linear-gradient(135deg, var(--primary), var(--primary-dark));
+    color: #ffffff;
+    border-bottom-right-radius: 8px;
+    box-shadow: 0 4px 12px rgba(0, 102, 255, 0.2);
+}
+
+.message.assistant .message-content {
+    background: var(--surface-elevated);
+    color: var(--text);
+    border-bottom-left-radius: 8px;
+    border: 1px solid var(--border);
+}
+.message-content h1, .message-content h2, .message-content h3, .message-content h4 {
+    color: var(--accent);
+    margin: 1.25rem 0 0.5rem 0;
+    font-weight: 600;
+    line-height: 1.3;
+    text-shadow: 0 1px 2px rgba(0, 212, 170, 0.1);
+}
+.message-content h1 { 
+    font-size: 1.35rem; 
+    background: linear-gradient(135deg, var(--accent), #00b894);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+}
+.message-content h2 { 
+    font-size: 1.2rem;
+    color: #00b894;
+}
+.message-content h3 { 
+    font-size: 1.05rem;
+    color: var(--accent);
+}
+.message-content h4 { 
+    font-size: 0.95rem;
+    color: #74b9ff;
+}
+.message-content p {
+    margin: 0.75rem 0;
+    line-height: 1.65;
+    color: var(--text);
+}
+.message-content ul, .message-content ol {
+    margin: 0.75rem 0;
+    padding-left: 1.5rem;
+    line-height: 1.6;
+}
+.message-content li {
+    margin: 0.3rem 0;
+    line-height: 1.6;
+    position: relative;
+}
+.message-content ul li::marker {
+    color: var(--accent);
+}
+.message-content ol li::marker {
+    color: var(--accent);
+    font-weight: 600;
+}
+.message-content table {
+    width: 100%;
+    border-collapse: collapse;
+    margin: 1rem 0;
+    font-size: 0.9rem;
+}
+.message-content th, .message-content td {
+    border: 1px solid var(--border);
+    padding: 0.5rem 0.75rem;
+    text-align: left;
+}
+.message-content th {
+    background: var(--surface);
+    font-weight: 600;
+    color: var(--accent);
+}
+.message-content strong {
+    background: linear-gradient(135deg, var(--accent), #74b9ff);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    font-weight: 700;
+    text-shadow: 0 1px 2px rgba(0, 212, 170, 0.2);
+}
+.message-content em {
+    color: #a29bfe;
+    font-style: italic;
+    background: rgba(162, 155, 254, 0.1);
+    padding: 0.1rem 0.2rem;
+    border-radius: 3px;
+}
+.message-content code {
+    background: linear-gradient(135deg, rgba(116, 185, 255, 0.15), rgba(0, 212, 170, 0.1));
+    border: 1px solid rgba(116, 185, 255, 0.3);
+    padding: 0.2rem 0.5rem;
+    border-radius: 6px;
+    font-family: 'SF Mono', Consolas, 'Courier New', monospace;
+    font-size: 0.85rem;
+    color: #74b9ff;
+    font-weight: 600;
+    text-shadow: 0 1px 2px rgba(116, 185, 255, 0.2);
+}
+.message.user .message-content strong,
+.message.user .message-content code,
+.message.user .message-content em {
+    color: rgba(255, 255, 255, 0.95);
+    background: rgba(255, 255, 255, 0.1);
+    -webkit-text-fill-color: rgba(255, 255, 255, 0.95);
+}
+.message-content pre {
+    background: var(--background);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 1rem;
+    margin: 1rem 0;
+    overflow-x: auto;
+    font-family: 'SF Mono', Consolas, 'Courier New', monospace;
+    font-size: 0.85rem;
+    line-height: 1.5;
+}
+.message-content pre code {
+    background: none;
+    border: none;
+    padding: 0;
+    font-size: inherit;
+}
+.message-content blockquote {
+    border-left: 3px solid var(--accent);
+    padding-left: 1rem;
+    margin: 1rem 0;
+    color: var(--text-secondary);
+    font-style: italic;
+    background: rgba(0, 212, 170, 0.05);
+    padding: 0.75rem 0 0.75rem 1rem;
+    border-radius: 0 4px 4px 0;
+}
+.message-content a {
+    color: var(--accent);
+    text-decoration: none;
+    border-bottom: 1px solid transparent;
+    transition: border-color 0.2s ease;
+}
+.message-content a:hover {
+    border-bottom-color: var(--accent);
+}
+.message.user .message-content {
+    word-wrap: break-word;
+    white-space: pre-wrap;
+}
+.message.user .message-content strong,
+.message.user .message-content code {
+    color: rgba(255, 255, 255, 0.9);
+}
+
+.message-meta {
+    font-size: 0.75rem;
+    color: var(--text-muted);
+    margin-top: 0.5rem;
+    font-weight: 500;
+}
+
+.sources {
+    margin-top: 1rem;
+    padding-top: 1rem;
+    border-top: 1px solid var(--border);
+    font-size: 0.8rem;
+    color: var(--text-secondary);
+}
+
+.sources span {
+    display: inline-block;
+    background: rgba(0, 102, 255, 0.1);
+    border: 1px solid rgba(0, 102, 255, 0.2);
+    padding: 0.25rem 0.75rem;
+    border-radius: 6px;
+    margin: 0.25rem 0.5rem 0.25rem 0;
+    font-weight: 500;
+    font-size: 0.75rem;
+}
+
+.input-area {
+    padding: 2rem;
+    background: linear-gradient(180deg, var(--surface), var(--surface-elevated));
+    border-top: 1px solid var(--border);
+}
+
+.input-container {
+    display: flex;
+    gap: 1rem;
+    align-items: stretch;
+}
+
+.input-field {
+    flex: 1;
+    padding: 1rem 1.5rem;
+    background: var(--background);
+    border: 2px solid var(--border);
+    border-radius: 28px;
+    color: var(--text);
+    font-size: 0.95rem;
+    outline: none;
+    transition: all 0.2s cubic-bezier(0.2, 0, 0.2, 1);
+    font-weight: 400;
+}
+
+.input-field:focus {
+    border-color: var(--primary);
+    box-shadow: 0 0 0 4px var(--border-focus);
+    background: var(--surface);
+}
+
+.input-field::placeholder {
+    color: var(--text-muted);
+    font-weight: 400;
+}
+
+.send-button {
+    padding: 1rem 2rem;
+    background: linear-gradient(135deg, var(--primary), var(--primary-dark));
+    color: #ffffff;
+    border: none;
+    border-radius: 28px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.2s cubic-bezier(0.2, 0, 0.2, 1);
+    font-size: 0.95rem;
+    box-shadow: 0 4px 12px rgba(0, 102, 255, 0.2);
+}
+
+.send-button:hover:not(:disabled) {
+    transform: translateY(-2px);
+    box-shadow: 0 8px 24px rgba(0, 102, 255, 0.3);
+}
+
+.send-button:active {
+    transform: translateY(0);
+}
+
+.send-button:disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+    transform: none;
+    box-shadow: 0 4px 12px rgba(0, 102, 255, 0.1);
+}
+
+.examples {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 1rem;
+    margin-top: 1rem;
+}
+
+.example {
+    background: linear-gradient(135deg, var(--surface), var(--surface-elevated));
+    border: 1px solid var(--border);
+    border-radius: 12px;
+    padding: 1.5rem;
+    cursor: pointer;
+    transition: all 0.3s cubic-bezier(0.2, 0, 0.2, 1);
+    position: relative;
+    overflow: hidden;
+}
+
+.example::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: -100%;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(90deg, transparent, rgba(0, 102, 255, 0.05), transparent);
+    transition: left 0.5s ease;
+}
+
+.example:hover::before {
+    left: 100%;
+}
+
+.example:hover {
+    border-color: var(--primary);
+    transform: translateY(-4px);
+    box-shadow: 0 12px 32px rgba(0, 0, 0, 0.2);
+    background: linear-gradient(135deg, var(--surface-elevated), var(--surface));
+}
+
+.example-title {
+    font-weight: 600;
+    color: var(--text);
+    margin-bottom: 0.5rem;
+    font-size: 0.95rem;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+.example-title i {
+    color: var(--primary);
+    font-size: 1rem;
+    width: 20px;
+    text-align: center;
+}
+
+.example-desc {
+    font-size: 0.85rem;
+    color: var(--text-secondary);
+    font-weight: 400;
+}
+
+.loading {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.5rem;
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+.loading::after {
+    content: '';
+    width: 14px;
+    height: 14px;
+    border: 2px solid currentColor;
+    border-top-color: transparent;
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+.loading-indicator {
+    display: none;
+    background: var(--surface-elevated);
+    border: 1px solid var(--border);
+    border-radius: 12px;
+    padding: 1.5rem;
+    margin: 1rem 0;
+    text-align: center;
+    color: var(--text-secondary);
+}
+.loading-indicator.active {
+    display: block;
+}
+.loading-spinner {
+    display: inline-block;
+    width: 20px;
+    height: 20px;
+    border: 2px solid var(--border);
+    border-top-color: var(--primary);
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+    margin-right: 0.5rem;
+}
+.progress-container {
+    width: 100%;
+    height: 4px;
+    background: var(--border);
+    border-radius: 2px;
+    overflow: hidden;
+    margin: 10px 0 0 0;
+}
+.progress-bar {
+    height: 100%;
+    background: linear-gradient(90deg, var(--primary), var(--accent));
+    border-radius: 2px;
+    transition: width 0.3s ease;
+    width: 0%;
+}
+.status-indicator {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 0.75rem 1rem;
+    font-size: 0.85rem;
+    color: var(--text-secondary);
+    opacity: 0;
+    transform: translateY(-10px);
+    transition: all 0.3s ease;
+    z-index: 1000;
+}
+.status-indicator.show {
+    opacity: 1;
+    transform: translateY(0);
+}
+.status-indicator.processing {
+    border-color: var(--primary);
+    background: linear-gradient(135deg, rgba(0, 102, 255, 0.05), rgba(0, 102, 255, 0.02));
+}
+
+.visualization-container {
+    margin: 1.5rem 0;
+    background: var(--surface-elevated);
+    border-radius: 12px;
+    padding: 1.5rem;
+    border: 1px solid var(--border);
+}
+
+.welcome {
+    text-align: center;
+    padding: 4rem 2rem;
+    color: var(--text-secondary);
+}
+
+.welcome h3 {
+    font-size: 1.25rem;
+    font-weight: 600;
+    margin-bottom: 0.5rem;
+    color: var(--text);
+}
+
+.welcome p {
+    font-size: 0.95rem;
+    font-weight: 400;
+}
+
+@media (max-width: 768px) {
+    .container {
+        padding: 1rem;
+    }
+    
+    .header-content {
+        flex-direction: column;
+        gap: 1rem;
+    }
+    
+    .header-text {
+        text-align: center;
+    }
+    
+    .header h1 {
+        font-size: 1.75rem;
+    }
+    
+    .chat-messages {
+        height: 400px;
+        padding: 1.5rem;
+    }
+    
+    .message-content {
+        max-width: 85%;
+        padding: 1rem 1.25rem;
+    }
+    
+    .input-area {
+        padding: 1.5rem;
+    }
+    
+    .input-container {
+        flex-direction: column;
+        gap: 0.75rem;
+    }
+    
+    .send-button {
+        align-self: stretch;
+    }
+    
+    .examples {
+        grid-template-columns: 1fr;
+    }
+}

templates/index.html

@@ -0,0 +1,104 @@
+<!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 24 24%22><path fill=%22%2300d4aa%22 d=%22M12 2L2 7v10c0 5.5 3.8 7.7 9 9 5.2-1.3 9-3.5 9-9V7l-10-5z%22/></svg>">
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
+    <link rel="stylesheet" href="/static/styles.css">
+</head>
+<body>
+    <div id="statusIndicator" class="status-indicator">
+        <span id="statusText">Ready</span>
+    </div>
+    
+    <div class="container">
+        <div class="header">
+            <div class="header-content">
+                <div class="header-text">
+                    <h1><span class="brand">Web3</span> Research Co-Pilot</h1>
+                    <p>Professional cryptocurrency analysis and market intelligence</p>
+                </div>
+                <div class="header-controls">
+                    <div class="llm-toggle">
+                        <span class="toggle-label">AI Model:</span>
+                        <label class="switch">
+                            <input type="checkbox" id="geminiToggle" title="Switch between Ollama (Local) and Gemini (Cloud)">
+                            <span class="slider round">
+                                <span class="slider-text-off">Ollama</span>
+                                <span class="slider-text-on">Gemini</span>
+                            </span>
+                        </label>
+                    </div>
+                    <button id="themeToggle" class="theme-toggle" title="Toggle theme">
+                        <i class="fas fa-moon"></i>
+                    </button>
+                </div>
+            </div>
+        </div>
+
+        <div id="status" class="status checking">
+            <span>Initializing research systems...</span>
+        </div>
+
+        <div class="chat-interface">
+            <div id="chatMessages" class="chat-messages">
+                <div class="welcome">
+                    <h3>Welcome to Web3 Research Co-Pilot</h3>
+                    <p>Ask about market trends, DeFi protocols, or blockchain analytics</p>
+                </div>
+            </div>
+            <div id="loadingIndicator" class="loading-indicator">
+                <div class="loading-spinner"></div>
+                <span id="loadingText">Processing your research query...</span>
+                <div class="progress-container">
+                    <div class="progress-bar" style="width: 0%;"></div>
+                </div>
+            </div>
+            <div class="input-area">
+                <div class="input-container">
+                    <input 
+                        type="text" 
+                        id="queryInput" 
+                        class="input-field"
+                        placeholder="Research Bitcoin trends, analyze DeFi yields, compare protocols..."
+                        maxlength="500"
+                    >
+                    <button id="sendBtn" class="send-button">Research</button>
+                </div>
+            </div>
+        </div>
+
+        <div class="examples">
+            <div class="example" onclick="setQuery('Analyze Bitcoin price trends and institutional adoption patterns')">
+                <div class="example-title"><i class="fas fa-chart-line"></i> Market Analysis</div>
+                <div class="example-desc">Bitcoin trends, institutional flows, and market sentiment analysis</div>
+            </div>
+            <div class="example" onclick="setQuery('Compare top DeFi protocols by TVL, yield, and risk metrics across chains')">
+                <div class="example-title"><i class="fas fa-coins"></i> DeFi Intelligence</div>
+                <div class="example-desc">Protocol comparison, yield analysis, and cross-chain opportunities</div>
+            </div>
+            <div class="example" onclick="setQuery('Evaluate Ethereum Layer 2 scaling solutions and adoption metrics')">
+                <div class="example-title"><i class="fas fa-layer-group"></i> Layer 2 Research</div>
+                <div class="example-desc">Scaling solutions, transaction costs, and ecosystem growth</div>
+            </div>
+            <div class="example" onclick="setQuery('Find optimal yield farming strategies with risk assessment')">
+                <div class="example-title"><i class="fas fa-seedling"></i> Yield Optimization</div>
+                <div class="example-desc">Cross-chain opportunities, APY tracking, and risk analysis</div>
+            </div>
+            <div class="example" onclick="setQuery('Track whale movements and large Bitcoin transactions today')">
+                <div class="example-title"><i class="fas fa-fish"></i> Whale Tracking</div>
+                <div class="example-desc">Large transactions, wallet analysis, and market impact</div>
+            </div>
+            <div class="example" onclick="setQuery('Analyze gas fees and network congestion across blockchains')">
+                <div class="example-title"><i class="fas fa-tachometer-alt"></i> Network Analytics</div>
+                <div class="example-desc">Gas prices, network utilization, and cost comparisons</div>
+            </div>
+        </div>
+    </div>
+
+    <script src="/static/app.js"></script>
+</body>
+</html>

test_complete_pipeline.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""
+Complete pipeline test for Web3 Research Agent with Ollama fallback
+Tests the entire flow: API calls → LLM processing → Response generation
+"""
+
+import asyncio
+import sys
+import os
+sys.path.append('.')
+
+async def test_complete_pipeline():
+    print("🧪 Testing Complete Web3 Research Pipeline with Ollama Fallback")
+    print("=" * 60)
+    
+    # Test 1: Initialize the research agent
+    print("\n1️⃣ Testing Research Agent Initialization...")
+    try:
+        from src.agent.research_agent import Web3ResearchAgent
+        agent = Web3ResearchAgent()
+        
+        if agent.enabled:
+            print(f"✅ Primary LLM (Gemini) initialized successfully")
+        else:
+            print("⚠️ Primary LLM failed, will test Ollama fallback")
+        
+        print(f"✅ Agent initialized with {len(agent.tools)} tools")
+        for tool in agent.tools:
+            print(f"   - {tool.name}")
+            
+    except Exception as e:
+        print(f"❌ Agent initialization failed: {e}")
+        return False
+    
+    # Test 2: Test Ollama connection
+    print("\n2️⃣ Testing Ollama Connection...")
+    try:
+        import requests
+        response = requests.get("http://localhost:11434/api/tags", timeout=5)
+        if response.status_code == 200:
+            models = response.json().get("models", [])
+            print(f"✅ Ollama connected. Available models: {[m['name'] for m in models]}")
+            
+            # Test direct Ollama inference
+            test_response = requests.post(
+                "http://localhost:11434/api/generate",
+                json={
+                    "model": "llama3.1:8b",
+                    "prompt": "What is DeFi in one sentence?",
+                    "stream": False
+                },
+                timeout=30
+            )
+            
+            if test_response.status_code == 200:
+                result = test_response.json()
+                print(f"✅ Ollama inference test: {result['response'][:100]}...")
+            else:
+                print(f"❌ Ollama inference failed: {test_response.status_code}")
+                
+        else:
+            print(f"❌ Ollama connection failed: {response.status_code}")
+            
+    except Exception as e:
+        print(f"❌ Ollama test failed: {e}")
+    
+    # Test 3: Test API integrations
+    print("\n3️⃣ Testing API Integrations...")
+    
+    # Test DeFiLlama
+    try:
+        from src.tools.defillama_tool import DeFiLlamaTool
+        defillama = DeFiLlamaTool()
+        result = await defillama._arun("top 3 defi protocols")
+        if result and "⚠️" not in result:
+            print(f"✅ DeFiLlama API: {result[:80]}...")
+        else:
+            print(f"⚠️ DeFiLlama API: {result[:80]}...")
+    except Exception as e:
+        print(f"❌ DeFiLlama test failed: {e}")
+    
+    # Test CoinGecko
+    try:
+        from src.tools.coingecko_tool import CoinGeckoTool
+        coingecko = CoinGeckoTool()
+        result = await coingecko._arun("bitcoin price")
+        if result and "⚠️" not in result:
+            print(f"✅ CoinGecko API: {result[:80]}...")
+        else:
+            print(f"⚠️ CoinGecko API: {result[:80]}...")
+    except Exception as e:
+        print(f"❌ CoinGecko test failed: {e}")
+    
+    # Test Chart Data
+    try:
+        from src.tools.chart_data_tool import ChartDataTool
+        chart_tool = ChartDataTool()
+        result = await chart_tool._arun("price_chart", "bitcoin", "7d")
+        if result and len(result) > 100:
+            print(f"✅ Chart Data: Generated {len(result)} chars of chart data")
+        else:
+            print(f"⚠️ Chart Data: {result[:80]}...")
+    except Exception as e:
+        print(f"❌ Chart Data test failed: {e}")
+    
+    # Test 4: Test complete research query
+    print("\n4️⃣ Testing Complete Research Query...")
+    try:
+        # Force Ollama fallback by setting GEMINI_API_KEY to invalid
+        original_key = os.environ.get('GEMINI_API_KEY')
+        os.environ['GEMINI_API_KEY'] = 'invalid_key_for_testing'
+        
+        # Reinitialize agent to trigger fallback
+        agent_fallback = Web3ResearchAgent()
+        
+        if agent_fallback.fallback_llm and agent_fallback.ollama_available:
+            print("✅ Ollama fallback initialized successfully")
+            
+            # Test with simple query first
+            simple_result = await agent_fallback.research_query(
+                "What is Bitcoin? Give a brief answer."
+            )
+            
+            if simple_result and simple_result.get('success'):
+                response_text = simple_result.get('result', simple_result.get('response', 'No response text'))
+                llm_used = simple_result.get('metadata', {}).get('llm_used', 'Unknown')
+                print(f"✅ Query successful with {llm_used}: {response_text[:100]}...")
+                
+                # Now test with Web3 data integration  
+                web3_result = await agent_fallback.research_query(
+                    "Get Bitcoin price and explain current market trends"
+                )
+                
+                if web3_result and web3_result.get('success'):
+                    web3_response = web3_result.get('result', web3_result.get('response', 'No response text'))
+                    web3_llm = web3_result.get('metadata', {}).get('llm_used', 'Unknown')
+                    print(f"✅ Web3 integration with {web3_llm}: {web3_response[:100]}...")
+                    print(f"   Sources: {web3_result.get('sources', [])}")
+                    visualizations = web3_result.get('visualizations', web3_result.get('metadata', {}).get('visualizations', []))
+                    print(f"   Visualizations: {len(visualizations)}")
+                else:
+                    print(f"⚠️ Web3 integration: {web3_result}")
+                    
+            else:
+                print(f"❌ Query failed: {simple_result}")
+        else:
+            print("❌ Ollama fallback initialization failed")
+            
+        # Restore original key
+        if original_key:
+            os.environ['GEMINI_API_KEY'] = original_key
+        else:
+            os.environ.pop('GEMINI_API_KEY', None)
+            
+    except Exception as e:
+        print(f"❌ Complete query test failed: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    print("\n" + "=" * 60)
+    print("🏁 Pipeline Test Complete!")
+    
+    return True
+
+if __name__ == "__main__":
+    asyncio.run(test_complete_pipeline())

test_response_clean.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""
+Quick test to verify response cleaning works properly
+"""
+
+import asyncio
+import sys
+import os
+
+# Add src to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+from src.agent.research_agent import Web3ResearchAgent
+
+async def test_response_cleaning():
+    """Test that responses are properly cleaned of LangChain metadata"""
+    print("🧪 Testing response cleaning...")
+    
+    agent = Web3ResearchAgent()
+    
+    if not agent.enabled:
+        print("❌ Agent not enabled")
+        return False
+    
+    try:
+        print("📊 Testing simple Bitcoin price query...")
+        result = await agent.research_query("What is Bitcoin current price?", use_gemini=True)
+        
+        if result['success']:
+            response_content = result['result']
+            print(f"✅ Query successful!")
+            print(f"📈 Response type: {type(response_content)}")
+            print(f"📄 Response preview: {response_content[:200]}...")
+            
+            # Check if response contains LangChain metadata (bad)
+            if "additional_kwargs" in str(response_content) or "response_metadata" in str(response_content):
+                print("❌ Response contains LangChain metadata - not properly cleaned")
+                return False
+            else:
+                print("✅ Response properly cleaned - no LangChain metadata found")
+                return True
+        else:
+            print(f"❌ Query failed: {result.get('error', 'Unknown error')}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Test failed with exception: {e}")
+        return False
+
+async def main():
+    success = await test_response_cleaning()
+    if success:
+        print("\n🎉 Response cleaning test passed!")
+        return 0
+    else:
+        print("\n❌ Response cleaning test failed!")
+        return 1
+
+if __name__ == "__main__":
+    exit_code = asyncio.run(main())
+    sys.exit(exit_code)

validate_startup.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Comprehensive startup validation script for Web3 Research Co-Pilot
+Validates syntax, imports, and configurations before application startup
+"""
+
+import ast
+import sys
+import os
+import json
+import importlib.util
+from pathlib import Path
+from typing import List, Dict, Any, Tuple
+
+def validate_python_syntax(file_path: str) -> Tuple[bool, str]:
+    """Validate Python file syntax."""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            source = f.read()
+        
+        ast.parse(source)
+        return True, "OK"
+    except SyntaxError as e:
+        return False, f"Syntax error at line {e.lineno}: {e.msg}"
+    except Exception as e:
+        return False, f"Parse error: {str(e)}"
+
+def validate_imports(file_path: str) -> Tuple[bool, List[str]]:
+    """Validate that all imports in a Python file can be resolved."""
+    issues = []
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            source = f.read()
+        
+        tree = ast.parse(source)
+        
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    try:
+                        importlib.import_module(alias.name)
+                    except ImportError:
+                        issues.append(f"Cannot import: {alias.name}")
+            
+            elif isinstance(node, ast.ImportFrom):
+                if node.module:
+                    try:
+                        importlib.import_module(node.module)
+                    except ImportError:
+                        issues.append(f"Cannot import module: {node.module}")
+        
+        return len(issues) == 0, issues
+    except Exception as e:
+        return False, [f"Import validation error: {str(e)}"]
+
+def validate_json_files() -> Tuple[bool, List[str]]:
+    """Validate JSON configuration files."""
+    issues = []
+    json_files = [
+        "pyproject.toml",  # Will skip if not JSON
+        "app_config.yaml"  # Will skip if not JSON
+    ]
+    
+    for file_path in json_files:
+        if os.path.exists(file_path) and file_path.endswith('.json'):
+            try:
+                with open(file_path, 'r') as f:
+                    json.load(f)
+            except json.JSONDecodeError as e:
+                issues.append(f"Invalid JSON in {file_path}: {str(e)}")
+            except Exception as e:
+                issues.append(f"Error reading {file_path}: {str(e)}")
+    
+    return len(issues) == 0, issues
+
+def validate_environment_variables() -> Tuple[bool, List[str]]:
+    """Validate required environment variables."""
+    issues = []
+    optional_vars = [
+        "CRYPTOCOMPARE_API_KEY",
+        "ETHERSCAN_API_KEY", 
+        "COINGECKO_API_KEY"
+    ]
+    
+    for var in optional_vars:
+        if not os.getenv(var):
+            issues.append(f"Optional environment variable {var} not set (will use free tier)")
+    
+    return True, issues  # All env vars are optional
+
+def main():
+    """Run comprehensive startup validation."""
+    print("🔍 Starting comprehensive validation...")
+    
+    # Get all Python files
+    python_files = []
+    for root, dirs, files in os.walk("."):
+        # Skip __pycache__ directories
+        dirs[:] = [d for d in dirs if d != "__pycache__"]
+        
+        for file in files:
+            if file.endswith(".py"):
+                python_files.append(os.path.join(root, file))
+    
+    print(f"📁 Found {len(python_files)} Python files to validate")
+    
+    all_valid = True
+    
+    # 1. Syntax validation
+    print("\n1️⃣ Validating Python syntax...")
+    syntax_issues = []
+    for file_path in python_files:
+        is_valid, message = validate_python_syntax(file_path)
+        if not is_valid:
+            syntax_issues.append(f"{file_path}: {message}")
+            all_valid = False
+        else:
+            print(f"  ✅ {file_path}")
+    
+    if syntax_issues:
+        print("❌ Syntax Issues Found:")
+        for issue in syntax_issues:
+            print(f"  - {issue}")
+    
+    # 2. Critical imports validation (only for main files)
+    print("\n2️⃣ Validating critical imports...")
+    critical_files = ["app.py", "src/agent/research_agent.py"]
+    import_issues = []
+    
+    for file_path in critical_files:
+        if os.path.exists(file_path):
+            is_valid, issues = validate_imports(file_path)
+            if not is_valid:
+                for issue in issues:
+                    import_issues.append(f"{file_path}: {issue}")
+            else:
+                print(f"  ✅ {file_path}")
+    
+    # Show non-critical import issues as warnings
+    if import_issues:
+        print("⚠️  Import Warnings (may use fallbacks):")
+        for issue in import_issues:
+            print(f"  - {issue}")
+    
+    # 3. JSON validation
+    print("\n3️⃣ Validating configuration files...")
+    json_valid, json_issues = validate_json_files()
+    if not json_valid:
+        print("�� Configuration Issues:")
+        for issue in json_issues:
+            print(f"  - {issue}")
+        all_valid = False
+    else:
+        print("  ✅ Configuration files valid")
+    
+    # 4. Environment validation
+    print("\n4️⃣ Validating environment...")
+    env_valid, env_issues = validate_environment_variables()
+    if env_issues:
+        print("ℹ️  Environment Info:")
+        for issue in env_issues:
+            print(f"  - {issue}")
+    else:
+        print("  ✅ Environment configured")
+    
+    # Final result
+    print(f"\n{'🎉' if all_valid else '❌'} Validation {'PASSED' if all_valid else 'FAILED'}")
+    
+    if not all_valid:
+        print("\n🛠️  Please fix the issues above before starting the application")
+        sys.exit(1)
+    else:
+        print("\n✅ All critical validations passed - ready to start!")
+        sys.exit(0)
+
+if __name__ == "__main__":
+    main()

version.py

@@ -0,0 +1,2 @@
+# Version identifier for debugging
+VERSION = "1.2.1-response-cleanup-fix"