Merge pull request #20 from debabratamishra/feat/web_search

Web Search Integration

Author: debabratamishra

.env.example

@@ -24,6 +24,14 @@ NUMEXPR_NUM_THREADS=4
 # vLLM Configuration (Optional)
 # HF_TOKEN=your-huggingface-token-here
 
+# Web Search Configuration
+# Get your API key from https://serpapi.com/
+SERP_API_KEY=your-serpapi-key-here
+# Optional: Maximum number of search results to retrieve (default: 10)
+WEB_SEARCH_MAX_RESULTS=10
+# Optional: Timeout for web search requests in seconds (default: 30)
+WEB_SEARCH_TIMEOUT=30
+
 # Cache directories (automatically configured by docker-compose)
 # HUGGINGFACE_CACHE_DIR=${HOME}/.cache/huggingface
 # OLLAMA_CACHE_DIR=${HOME}/.ollama

README.md

@@ -37,6 +37,7 @@ A robust, production-ready web interface for Large Language Models (LLMs) featur
 - ⚡ **High-Performance API** - Async FastAPI backend for scalable LLM processing
 - 🧠 **Dual Backend Support** - Seamlessly switch between Ollama (local) and vLLM (Hugging Face) backends
 - 📚 **RAG Integration** - Upload documents (PDFs, DOCX, TXT) with enhanced extraction and query with context-aware responses
+- 🔍 **Web Search Integration** - Optional real-time web search powered by SerpAPI with AI-driven synthesis
 - 🔄 **Auto-Failover** - Intelligent backend detection with graceful fallbacks
 - 🤖 **Multi-Model Support** - Access to popular models through vLLM or local Ollama models
 
@@ -231,6 +232,8 @@ mkdir -p uploads .streamlit
 | `/models` | GET | Available Ollama models |
 | `/api/chat` | POST | Process chat messages (supports both Ollama and vLLM backends) |
 | `/api/chat/stream` | POST | Streaming chat responses (supports both backends) |
+| `/api/chat/web-search` | POST | Process chat with optional web search integration |
+| `/api/chat/serp-status` | GET | Check SerpAPI token configuration status |
 | `/api/rag/upload` | POST | Upload documents for RAG processing |
 | `/api/rag/query` | POST | Query uploaded documents with context-aware responses |
 | `/api/rag/documents` | GET | List uploaded documents |
@@ -246,7 +249,8 @@ mkdir -p uploads .streamlit
 3. **Configure Models:** 
    - For Ollama: Select from locally installed models
    - For vLLM: Choose from popular models or enter custom model names
-4. Enter your message and receive AI responses
+4. **Optional Web Search:** Enable the web search toggle to enhance responses with real-time internet data
+5. Enter your message and receive AI responses
 
 ### Document Q\&A (RAG)
 
@@ -316,6 +320,59 @@ export OLLAMA_BASE_URL="http://localhost:11434"
 export UPLOAD_FOLDER="./uploads"
 ```
 
+### Web Search Configuration (Optional)
+
+LiteMindUI supports optional web search integration powered by SerpAPI. When enabled, the system can retrieve real-time information from the internet and synthesize it with your local LLM.
+
+#### Setting up SerpAPI
+
+1. **Get your API key:**
+   - Visit [https://serpapi.com/](https://serpapi.com/)
+   - Sign up for a free account (100 searches/month on free tier)
+   - Navigate to your dashboard to find your API key
+
+2. **Configure the API key:**
+   
+   Add to your `.env` file:
+   ```bash
+   SERP_API_KEY=your-serpapi-key-here
+   ```
+   
+   Or export as environment variable:
+   ```bash
+   export SERP_API_KEY="your-serpapi-key-here"
+   ```
+
+3. **Optional settings:**
+   ```bash
+   # Maximum number of search results to retrieve (default: 10)
+   WEB_SEARCH_MAX_RESULTS=10
+   
+   # Timeout for web search requests in seconds (default: 30)
+   WEB_SEARCH_TIMEOUT=30
+   ```
+
+#### Using Web Search
+
+1. Navigate to the **Chat** tab in the UI
+2. Look for the **Web Search** toggle in the prompt area
+3. Enable the toggle before submitting your query
+4. The system will:
+   - Retrieve top 10 search results from the web
+   - Synthesize the information using your selected LLM
+   - Display a comprehensive response with web context
+
+**Status Indicators:**
+- The sidebar displays your SerpAPI token status (valid/missing/invalid)
+- During search: "Searching web..." status message
+- During synthesis: "Synthesizing results..." status message
+
+**Fallback Behavior:**
+- If the SerpAPI token is missing or invalid, the system automatically falls back to local LLM processing
+- An error message will be displayed: "SerpAPI token is required to perform Web search. Defaulting to local results"
+
+**Note:** Web search is currently available in the Chat interface. RAG integration is planned for a future release.
+
 ## 🎯 Advanced Features
 
 - **Backend Detection:** Automatic FastAPI availability checking with local fallback

app/backend/api/chat.py

@@ -2,19 +2,25 @@
 Chat API endpoints
 """
 import logging
+from dotenv import load_dotenv
 from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
 
-from app.backend.models.api_models import ChatRequestEnhanced, ChatResponse
+# Ensure environment variables are loaded before importing services
+load_dotenv()
+
+from app.backend.models.api_models import ChatRequestEnhanced, ChatResponse, SerpTokenStatus
 from app.services.ollama import stream_ollama
 from app.services.vllm_service import vllm_service
+from app.services.web_search_service import WebSearchService
+from app.services.web_search_crew import WebSearchOrchestrator
 
 logger = logging.getLogger(__name__)
 
-router = APIRouter(prefix="/api/chat", tags=["chat"])
+router = APIRouter(tags=["chat"])
 
 
-@router.post("/", response_model=ChatResponse)
+@router.post("/api/chat", response_model=ChatResponse)
 async def chat_endpoint(request: ChatRequestEnhanced):
     """Single chat message processing"""
     logger.info(f"Chat request - Backend: {request.backend}, Model: {request.model}")
@@ -30,7 +36,7 @@ async def chat_endpoint(request: ChatRequestEnhanced):
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@router.post("/stream")
+@router.post("/api/chat/stream")
 async def chat_stream(request: ChatRequestEnhanced):
     """Stream chat responses"""
     logger.info(f"Streaming chat - Backend: {request.backend}, Model: {request.model}")
@@ -105,3 +111,140 @@ async def _stream_ollama_chat(request: ChatRequestEnhanced):
     messages = [{"role": "user", "content": request.message}]
     async for chunk in stream_ollama(messages, model=request.model, temperature=request.temperature):
         yield chunk
+
+
+@router.post("/api/chat/web-search")
+async def chat_web_search(request: ChatRequestEnhanced):
+    """Process chat with optional web search integration"""
+    logger.info(f"Web search chat request - use_web_search: {request.use_web_search}, Model: {request.model}")
+    
+    try:
+        # Validate that web search is requested
+        if not request.use_web_search:
+            logger.info("Web search not requested, routing to standard chat endpoint")
+            return await chat_stream(request)
+        
+        # Check if SerpAPI token is configured
+        web_search_service = WebSearchService()
+        token_validation = web_search_service.validate_token()
+        
+        if not token_validation["valid"]:
+            logger.warning(f"SerpAPI token invalid: {token_validation['message']}")
+            logger.info("Falling back to standard chat due to invalid token")
+            
+            # Return error message and fallback to standard chat
+            async def error_and_fallback():
+                error_msg = "SerpAPI token is required to perform Web search. Defaulting to local results.\n\n"
+                yield error_msg
+                
+                # Stream standard chat response
+                async for chunk in _stream_ollama_chat(request):
+                    yield chunk
+            
+            return StreamingResponse(error_and_fallback(), media_type="text/plain")
+        
+        # Route to web search handler
+        return await _handle_web_search_chat(request)
+        
+    except Exception as e:
+        logger.error(f"Web search endpoint error: {e}", exc_info=True)
+        logger.info("Falling back to standard chat due to error")
+        
+        # Fallback to standard chat on any error
+        async def error_fallback():
+            error_msg = f"Web search error: {str(e)}. Defaulting to local results.\n\n"
+            yield error_msg
+            
+            async for chunk in _stream_ollama_chat(request):
+                yield chunk
+        
+        return StreamingResponse(error_fallback(), media_type="text/plain")
+
+
+@router.get("/api/chat/serp-status", response_model=SerpTokenStatus)
+async def get_serp_token_status():
+    """Get SerpAPI token validation status"""
+    logger.info("Checking SerpAPI token status")
+    
+    try:
+        web_search_service = WebSearchService()
+        validation = web_search_service.validate_token()
+        
+        if validation["valid"]:
+            return SerpTokenStatus(
+                status="valid",
+                message=validation["message"]
+            )
+        else:
+            return SerpTokenStatus(
+                status="invalid",
+                message=validation["message"]
+            )
+            
+    except Exception as e:
+        logger.error(f"Error checking SerpAPI token status: {e}")
+        return SerpTokenStatus(
+            status="error",
+            message=f"Error checking token status: {str(e)}"
+        )
+
+
+async def _handle_web_search_chat(request: ChatRequestEnhanced):
+    """Handle web search chat request by routing to orchestrator"""
+    logger.info("Routing to web search orchestrator")
+    
+    async def event_generator():
+        try:
+            # Initialize orchestrator
+            orchestrator = WebSearchOrchestrator()
+            
+            # Build conversation history from request if available
+            conversation_history = []
+            # Note: ChatRequestEnhanced currently only has 'message', not full history
+            # If history is needed, it would be added to the model
+            
+            # Process query through orchestrator with streaming
+            async for chunk in orchestrator.process_query(
+                query=request.message,
+                conversation_history=conversation_history,
+                stream=True
+            ):
+                yield chunk + "\n"
+                
+        except Exception as e:
+            logger.error(f"Web search orchestrator error: {e}", exc_info=True)
+            yield f"Error during web search: {str(e)}\n"
+            yield "Falling back to local results...\n\n"
+            
+            # Fallback to standard chat
+            async for chunk in _stream_ollama_chat(request):
+                yield chunk + "\n"
+    
+    return StreamingResponse(event_generator(), media_type="text/plain")
+
+
+async def _stream_web_search_chat(request: ChatRequestEnhanced):
+    """Stream web search chat responses (helper for streaming)"""
+    try:
+        # Initialize orchestrator
+        orchestrator = WebSearchOrchestrator()
+        
+        # Build conversation history from request if available
+        conversation_history = []
+        
+        # Process query through orchestrator with streaming
+        async for chunk in orchestrator.process_query(
+            query=request.message,
+            conversation_history=conversation_history,
+            stream=True
+        ):
+            yield chunk
+            
+    except Exception as e:
+        logger.error(f"Web search streaming error: {e}", exc_info=True)
+        yield f"Error during web search: {str(e)}\n"
+        yield "Falling back to local results...\n\n"
+        
+        # Fallback to standard chat
+        async for chunk in _stream_ollama_chat(request):
+            yield chunk

app/backend/models/api_models.py

@@ -11,6 +11,7 @@ class ChatRequestEnhanced(BaseModel):
     temperature: Optional[float] = 0.7
     backend: Optional[str] = "ollama"
     hf_token: Optional[str] = None
+    use_web_search: Optional[bool] = False
 
 
 class RAGQueryRequestEnhanced(BaseModel):
@@ -105,3 +106,26 @@ class ErrorResponse(BaseModel):
     error: str
     detail: Optional[str] = None
     path: Optional[str] = None
+
+
+class WebSearchRequest(BaseModel):
+    query: str
+    num_results: Optional[int] = 10
+
+
+class WebSearchResult(BaseModel):
+    title: str
+    link: str
+    snippet: str
+    position: int
+
+
+class WebSearchResponse(BaseModel):
+    query: str
+    results: List[WebSearchResult]
+    total_results: int
+
+
+class SerpTokenStatus(BaseModel):
+    status: str
+    message: str

app/frontend/components/__init__.py

@@ -1 +1,5 @@
 # Components package
+
+from .web_search_toggle import WebSearchToggle, get_web_search_toggle
+
+__all__ = ['WebSearchToggle', 'get_web_search_toggle']