feat: Add Gemini/Ollama toggle functionality with API error fixes

✨ New Features:
- Add interactive toggle switch in UI to choose between Ollama (Local) and Gemini (Cloud)
- Dynamic LLM selection with preference persistence in localStorage
- Support both Ollama and Gemini in research agent with automatic fallbacks
- Real-time status updates showing which AI model is being used

�� Backend Changes:
- Update research agent to support both LLMs with use_gemini parameter
- Add _research_with_gemini_tools method for Gemini-powered research
- Update query request model to include use_gemini field
- Automatic LLM initialization and availability detection

🎨 Frontend Changes:
- Beautiful toggle switch with animated slider and labels
- Persistent user preference storage
- Dynamic status messages based on selected LLM
- Responsive design for header controls

🛠️ Bug Fixes:
- Fix CoinGecko API 401 errors by adding proper fallback to mock data
- Improved error handling for chart_data_tool API failures
- Better session cleanup to prevent connection warnings

🔒 Safety & Performance:
- AI safety validation for both Ollama and Gemini responses
- Proper timeout handling for both LLM types
- Graceful degradation when APIs fail or models unavailable

app.py

@@ -37,6 +37,7 @@ templates = Jinja2Templates(directory="templates")
 class QueryRequest(BaseModel):
     query: str
     chat_history: Optional[List[Dict[str, str]]] = []
+    use_gemini: bool = False
 
 class QueryResponse(BaseModel):
     success: bool
@@ -85,7 +86,7 @@ class Web3CoPilotService:
             self.airaa = None
             self.viz = None
     
-    async def process_query(self, query: str) -> QueryResponse:
+    async def process_query(self, query: str, use_gemini: bool = False) -> QueryResponse:
         """Process research query with comprehensive analysis"""
         logger.info("Processing research request...")
         
@@ -113,7 +114,7 @@ Configure GEMINI_API_KEY environment variable for full AI analysis."""
             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)
+            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"):
@@ -464,22 +465,23 @@ async def process_query_stream(request: QueryRequest):
             yield f"data: {json.dumps({'type': 'status', 'message': 'Executing tools and gathering data...', 'progress': 50})}\n\n"
             await asyncio.sleep(0.5)
             
-            # Send Ollama processing status with heartbeats
-            yield f"data: {json.dumps({'type': 'status', 'message': 'Ollama is analyzing data and generating response...', 'progress': 70})}\n\n"
+            # 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': 'Ollama is thinking deeply about your query...', 'progress': 75})}\n\n"
+            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': 'Still processing... Ollama generates detailed responses', 'progress': 80})}\n\n"
+            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))
+            query_task = asyncio.create_task(service.process_query(request.query, request.use_gemini))
             
             try:
                 # Send periodic heartbeats while waiting for Ollama
@@ -499,7 +501,8 @@ async def process_query_stream(request: QueryRequest):
                             raise asyncio.TimeoutError("Hard timeout reached")
                         
                         progress = min(85 + (heartbeat_count * 2), 95)  # Progress slowly from 85 to 95
-                        yield f"data: {json.dumps({'type': 'status', 'message': f'Ollama is still working... ({elapsed:.0f}s elapsed)', 'progress': progress})}\n\n"
+                        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()

src/agent/research_agent.py

@@ -22,41 +22,60 @@ class Web3ResearchAgent:
         self.fallback_llm = None
         self.tools = []
         self.enabled = False
+        self.gemini_available = False
         
         try:
-            if config.USE_OLLAMA_ONLY:
-                logger.info("🔧 Initializing in Ollama-only mode")
-                self._init_ollama_only()
-            else:
-                logger.info("🔧 Initializing with Gemini primary + Ollama fallback")
-                self._init_with_gemini_fallback()
+            # 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.enabled = True
                 
         except Exception as e:
             logger.error(f"Agent initialization failed: {e}")
             self.enabled = False
 
-    def _init_ollama_only(self):
-        """Initialize with only Ollama LLM"""
+    def _init_ollama(self):
+        """Initialize Ollama LLM"""
         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}")
-            
-            self.tools = self._initialize_tools()
-            self.enabled = True
-            
         except Exception as e:
             logger.error(f"Ollama initialization failed: {e}")
-            self.enabled = False
+            raise
+    
+    def _init_gemini(self):
+        """Initialize Gemini LLM"""
+        try:
+            self.llm = ChatGoogleGenerativeAI(
+                model="gemini-pro",
+                google_api_key=config.GEMINI_API_KEY,
+                temperature=0.1
+            )
+            self.gemini_available = True
+            logger.info("✅ Gemini initialized")
+        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"""
-        # This would be for future use when both are needed
-        pass
+        """Initialize with Gemini primary and Ollama fallback (deprecated - kept for compatibility)"""
+        self._init_ollama()
+        self._init_gemini()
 
     def _initialize_tools(self):
         tools = []
@@ -93,8 +112,8 @@ class Web3ResearchAgent:
         
         return tools
 
-    async def research_query(self, query: str) -> Dict[str, Any]:
-        """Research query with Ollama and tools - Enhanced with AI Safety"""
+    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)
@@ -140,8 +159,13 @@ class Web3ResearchAgent:
             }
         
         try:
-            logger.info("🤖 Processing with Ollama + Tools (Safety Enhanced)")
-            return await self._research_with_ollama_tools(sanitized_query)
+            # Choose LLM based on user preference and availability
+            if use_gemini and self.gemini_available:
+                logger.info("🤖 Processing with Gemini + Tools (Safety Enhanced)")
+                return await self._research_with_gemini_tools(sanitized_query)
+            else:
+                logger.info("🤖 Processing with Ollama + Tools (Safety Enhanced)")
+                return await self._research_with_ollama_tools(sanitized_query)
                 
         except Exception as e:
             logger.error(f"Research failed: {e}")
@@ -342,6 +366,126 @@ The system successfully gathered data from {len(suggested_tools)} tools:
             logger.error(f"Ollama tools research failed: {e}")
             raise e
 
+    async def _research_with_gemini_tools(self, query: str) -> Dict[str, Any]:
+        """Research using Gemini with tools"""
+        try:
+            # Step 1: Analyze query and suggest tools using Gemini
+            tool_analysis_prompt = f"""Based on this Web3/cryptocurrency research query, identify the most relevant tools to use.
+
+Query: "{query}"
+
+Available tools:
+- cryptocompare_data: Get current cryptocurrency prices and basic info
+- coingecko_data: Comprehensive market data and analytics
+- defillama_data: DeFi protocols, TVL, and yield farming data
+- etherscan_data: Ethereum blockchain data and transactions
+- chart_data_provider: Generate chart data for visualizations
+
+If charts/visualizations are mentioned, include chart_data_provider.
+
+Examples:
+- "Bitcoin price" → cryptocompare_data, chart_data_provider
+- "DeFi TVL" → defillama_data, chart_data_provider  
+- "Ethereum transactions" → etherscan_data
+
+Respond with only the tool names, comma-separated (no explanations)."""
+
+            tool_response = await self.llm.ainvoke(tool_analysis_prompt)
+            
+            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', 'coingecko_data', 'defillama_data', 
+                'etherscan_data', 'chart_data_provider'
+            }]
+            
+            logger.info(f"🛠️ Gemini suggested tools: {suggested_tools}")
+
+            # Step 2: Execute tools (same logic as Ollama version)
+            tool_results = []
+            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")
+            
+            # 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=30
+                )
+                logger.info(f"🎯 Gemini final response preview: {str(final_response)[:300]}...")
+                
+                # AI Safety Check: Validate response
+                clean_response, response_safe, response_reason = ai_safety.validate_gemini_response(str(final_response))
+                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*"
+                
+                final_response = clean_response
+                
+            except asyncio.TimeoutError:
+                logger.warning("⏱️ Gemini final response timed out, using tool data directly")
+                final_response = f"## Web3 Research Analysis\n\n{context[:1500]}\n\n*Analysis completed using available tools - Gemini response timed out*"
+            
+            logger.info("✅ Research successful with Gemini + tools")
+            
+            return {
+                "success": True,
+                "query": query,
+                "result": final_response,
+                "sources": [],
+                "metadata": {
+                    "llm_used": f"Gemini ({self.llm.model_name if hasattr(self.llm, 'model_name') else 'gemini-pro'})", 
+                    "tools_used": suggested_tools,
+                    "timestamp": datetime.now().isoformat()
+                }
+            }
+            
+        except Exception as e:
+            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

src/tools/chart_data_tool.py

@@ -84,9 +84,9 @@ class ChartDataTool(BaseTool):
             })
     
     async def _get_price_chart_data(self, symbol: str, days: int) -> str:
-        """Get real price chart data from CoinGecko API"""
+        """Get price chart data with fallback for API failures"""
         try:
-            # Import the CoinGecko tool to get real data
+            # First try to get real data from CoinGecko
             from src.tools.coingecko_tool import CoinGeckoTool
             
             coingecko = CoinGeckoTool()
@@ -107,42 +107,48 @@ class ChartDataTool(BaseTool):
             
             coin_id = symbol_map.get(symbol.lower(), symbol.lower())
             
-            # Get price history from CoinGecko
-            url = f"https://api.coingecko.com/api/v3/coins/{coin_id}/market_chart"
-            params = {"vs_currency": "usd", "days": days, "interval": "daily" if days > 90 else "hourly"}
-            
-            data = await coingecko.make_request(url, params=params)
-            
-            if not data or "prices" not in data:
-                # Fallback to mock data if API fails
-                logger.warning(f"CoinGecko API failed for {symbol}, using fallback data")
+            try:
+                # Use basic API endpoint that doesn't require premium
+                url = f"https://api.coingecko.com/api/v3/coins/{coin_id}/market_chart"
+                params = {"vs_currency": "usd", "days": days, "interval": "daily"}
+                
+                data = await coingecko.make_request(url, params=params)
+                
+                if data and "prices" in data:
+                    # Format the real data
+                    price_data = data.get("prices", [])
+                    volume_data = data.get("total_volumes", [])
+                    
+                    # Get current coin info
+                    coin_info = await coingecko.make_request(f"https://api.coingecko.com/api/v3/coins/{coin_id}")
+                    coin_name = coin_info.get("name", symbol.title()) if coin_info else symbol.title()
+                    
+                    return json.dumps({
+                        "chart_type": "price_chart", 
+                        "data": {
+                            "prices": price_data,
+                            "total_volumes": volume_data,
+                            "symbol": symbol.upper(),
+                            "name": coin_name
+                        },
+                        "config": {
+                            "title": f"{coin_name} Price Analysis ({days} days)",
+                            "timeframe": f"{days}d", 
+                            "currency": "USD"
+                        }
+                    })
+                else:
+                    raise Exception("No price data in response")
+                    
+            except Exception as api_error:
+                logger.error(f"Real 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)
             
-            # Format the real data
-            price_data = data.get("prices", [])
-            volume_data = data.get("total_volumes", [])
-            
-            # Get current coin info
-            coin_info = await coingecko.make_request(f"https://api.coingecko.com/api/v3/coins/{coin_id}")
-            coin_name = coin_info.get("name", symbol.title()) if coin_info else symbol.title()
-            
-            return json.dumps({
-                "chart_type": "price_chart", 
-                "data": {
-                    "prices": price_data,
-                    "total_volumes": volume_data,
-                    "symbol": symbol.upper(),
-                    "name": coin_name
-                },
-                "config": {
-                    "title": f"{coin_name} Price Analysis ({days} days)",
-                    "timeframe": f"{days}d", 
-                    "currency": "USD"
-                }
-            })
-            
         except Exception as e:
-            logger.error(f"Real price data failed: {e}")
+            logger.error(f"Price chart data generation failed: {e}")
+            # Final fallback to mock data
             return await self._get_mock_price_data(symbol, days)
     
     async def _get_mock_price_data(self, symbol: str, days: int) -> str:

src/utils/config.py

@@ -8,9 +8,9 @@ load_dotenv()
 
 @dataclass
 class Config:
-    # LLM Configuration - Ollama-only for testing (no API credits used)
-    GEMINI_API_KEY: str = ""  # Disabled to save credits
-    USE_OLLAMA_ONLY: bool = True  # Force Ollama-only mode
+    # 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

static/app.js

@@ -1,5 +1,38 @@
 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 {
@@ -68,7 +101,11 @@ async function sendQuery() {
                 'Accept': 'text/event-stream',
                 'Cache-Control': 'no-cache'
             },
-            body: JSON.stringify({ query, chat_history: chatHistory }),
+            body: JSON.stringify({ 
+                query, 
+                chat_history: chatHistory, 
+                use_gemini: useGemini 
+            }),
             signal: controller.signal,
             // Disable browser's default timeout behavior
             keepalive: true

static/styles.css

@@ -66,6 +66,109 @@ body {
     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);

templates/index.html

@@ -21,9 +21,21 @@
                     <h1><span class="brand">Web3</span> Research Co-Pilot</h1>
                     <p>Professional cryptocurrency analysis and market intelligence</p>
                 </div>
-                <button id="themeToggle" class="theme-toggle" title="Toggle theme">
-                    <i class="fas fa-moon"></i>
-                </button>
+                <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>