Update app.py

app.py

@@ -1,267 +1,259 @@
 import os
 import gradio as gr
-import requests
-import json
-import asyncio
-from typing import List, Dict, Any, Generator
+from typing import List
 import logging
-from duckduckgo_search import DDGS
-from bs4 import BeautifulSoup
-import re
+import logging.handlers
+import time
+import random
+from langchain_openai import ChatOpenAI
+from langchain_core.tools import tool
+from langgraph.prebuilt import create_react_agent
+from langchain_core.messages import HumanMessage
+from langchain_tavily import TavilySearch
+
+# Configuration - set to False to disable detailed logging
+ENABLE_DETAILED_LOGGING = True
+
+# Setup logging with rotation (7 days max)
+if ENABLE_DETAILED_LOGGING:
+    # Create formatter
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+    # Setup console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+
+    # Setup rotating file handler (7 days, daily rotation)
+    file_handler = logging.handlers.TimedRotatingFileHandler(
+        'agent.log',
+        when='midnight',
+        interval=1,
+        backupCount=7,  # Keep 7 days of logs
+        encoding='utf-8'
+    )
+    file_handler.setFormatter(formatter)
+
+    # Configure root logger
+    logging.basicConfig(
+        level=logging.INFO,
+        handlers=[console_handler, file_handler]
+    )
+else:
+    logging.basicConfig(level=logging.WARNING)
 
-logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# Configuration from environment variables
+llm_ip = os.environ.get('public_ip')
+llm_port = os.environ.get('port')
+llm_key = os.environ.get('api_key')
+llm_model = os.environ.get('model')
 
-llm_ip = os.environ.get('public_ip', DEFAULT_IP)
-llm_port = os.environ.get('port', DEFAULT_PORT)
-llm_key = os.environ.get('api_key', DEFAULT_KEY)
-llm_model = os.environ.get('model', DEFAULT_MODEL)
+# Tavily API configuration
+tavily_key = os.environ.get('tavily_key', '')
+if tavily_key:
+    os.environ['TAVILY_API_KEY'] = tavily_key
 
-class WebTools:
-    def __init__(self):
-        self.session = requests.Session()
-        self.session.headers.update({
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-        })
-        self.ddgs = DDGS()
+# Tavily search tool integration
 
-    def search_web(self, query: str, max_results: int = 5) -> str:
-        """Search the web using DuckDuckGo"""
-        try:
-            results = self.ddgs.text(query, max_results=max_results)
-            if not results:
-                return f"No search results found for: {query}"
-
-            formatted_results = f"Search results for '{query}':\n\n"
-            for i, result in enumerate(results, 1):
-                title = result.get('title', 'No title')
-                body = result.get('body', 'No description')
-                href = result.get('href', 'No URL')
-                formatted_results += f"{i}. **{title}**\n{body}\nURL: {href}\n\n"
-
-            return formatted_results
-        except Exception as e:
-            logger.error(f"Search error: {e}")
-            return f"Search error: {str(e)}"
-
-    def visit_website(self, url: str) -> str:
-        """Visit a website and extract its text content"""
-        try:
-            if not url.startswith(('http://', 'https://')):
-                url = 'https://' + url
-
-            response = self.session.get(url, timeout=10)
-            response.raise_for_status()
-
-            soup = BeautifulSoup(response.content, 'html.parser')
-
-            # Remove script and style elements
-            for script in soup(["script", "style", "nav", "footer", "header"]):
-                script.decompose()
-
-            # Get text content
-            text = soup.get_text()
-
-            # Clean up text
-            lines = (line.strip() for line in text.splitlines())
-            chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
-            text = ' '.join(chunk for chunk in chunks if chunk)
-
-            # Limit text length
-            if len(text) > 3000:
-                text = text[:3000] + "... (content truncated)"
-
-            return f"Content from {url}:\n\n{text}"
-        except Exception as e:
-            logger.error(f"Website visit error: {e}")
-            return f"Error visiting {url}: {str(e)}"
-
-class LLMClient:
+class ReactAgentChat:
     def __init__(self, ip: str, port: str, api_key: str, model: str):
         self.ip = ip
         self.port = port
         self.api_key = api_key
         self.model = model
-        self.base_url = f"http://{ip}:{port}/v1/chat/completions"
-
-    def call_llm(self, messages: List[Dict], max_tokens: int = 512, stream: bool = False):
-        """Call the LLM API"""
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {self.api_key}"
-        }
-        data = {
-            "model": self.model,
-            "messages": messages,
-            "max_tokens": max_tokens,
-            "stream": stream
-        }
+        self.agent = None
+        self._setup_agent()
 
+    def _setup_agent(self):
+        """Initialize the LangGraph ReAct agent"""
         try:
-            response = requests.post(self.base_url, headers=headers, json=data,
-                                   stream=stream, timeout=30)
-            response.raise_for_status()
-
-            if stream:
-                return response
+            if ENABLE_DETAILED_LOGGING:
+                logger.info(f"=== SETTING UP AGENT ===")
+                logger.info(f"LLM URL: http://{self.ip}:{self.port}/v1")
+                logger.info(f"Model: {self.model}")
+
+            # Create OpenAI-compatible model
+            llm = ChatOpenAI(
+                base_url=f"http://{self.ip}:{self.port}/v1",
+                api_key=self.api_key,
+                model=self.model,
+                temperature=0.7
+            )
+            if ENABLE_DETAILED_LOGGING:
+                logger.info("LLM created successfully")
+
+            # Define tools - use Tavily search API with graceful error handling
+            if tavily_key:
+                if ENABLE_DETAILED_LOGGING:
+                    logger.info("Setting up Tavily search tool")
+                try:
+                    # Create custom wrapper for Tavily with error handling
+                    @tool
+                    def web_search(query: str) -> str:
+                        """Search the web for current information about any topic."""
+                        try:
+                            tavily_tool = TavilySearch(
+                                max_results=5,
+                                topic="general",
+                                include_answer=True,
+                                search_depth="advanced"
+                            )
+                            result = tavily_tool.invoke({"query": query})
+                            if ENABLE_DETAILED_LOGGING:
+                                logger.info(f"Tavily search successful for query: {query}")
+                            return result
+                        except Exception as e:
+                            error_str = str(e).lower()
+                            if ENABLE_DETAILED_LOGGING:
+                                logger.error(f"Tavily search failed for query '{query}': {e}")
+
+                            # Check for rate limit or quota issues
+                            if any(keyword in error_str for keyword in ['rate limit', 'quota', 'limit exceeded', 'usage limit', 'billing']):
+                                if ENABLE_DETAILED_LOGGING:
+                                    logger.warning(f"Tavily rate limit/quota exceeded: {e}")
+                                return "I can't search the web right now."
+                            else:
+                                if ENABLE_DETAILED_LOGGING:
+                                    logger.error(f"Tavily API error: {e}")
+                                return "I can't search the web right now."
+
+                    search_tool = web_search
+                    if ENABLE_DETAILED_LOGGING:
+                        logger.info("Tavily search tool wrapper created successfully")
+                except Exception as e:
+                    if ENABLE_DETAILED_LOGGING:
+                        logger.error(f"Failed to create Tavily tool wrapper: {e}")
+                    # Fallback tool
+                    @tool
+                    def no_search(query: str) -> str:
+                        """Search tool unavailable."""
+                        return "I can't search the web right now."
+                    search_tool = no_search
             else:
-                result = response.json()
-                return result["choices"][0]["message"]["content"]
+                if ENABLE_DETAILED_LOGGING:
+                    logger.warning("No Tavily API key found, creating fallback tool")
+                @tool
+                def no_search(query: str) -> str:
+                    """Search tool unavailable."""
+                    if ENABLE_DETAILED_LOGGING:
+                        logger.error("Search attempted but no Tavily API key configured")
+                    return "I can't search the web right now."
+                search_tool = no_search
+
+            tools = [search_tool]
+            if ENABLE_DETAILED_LOGGING:
+                logger.info(f"Tools defined: {[tool.name for tool in tools]}")
+
+            # Bind tools to the model
+            model_with_tools = llm.bind_tools(tools)
+            if ENABLE_DETAILED_LOGGING:
+                logger.info("Tools bound to model")
+
+            # Create the ReAct agent
+            self.agent = create_react_agent(model_with_tools, tools)
+            if ENABLE_DETAILED_LOGGING:
+                logger.info("ReAct agent created successfully")
+
         except Exception as e:
-            logger.error(f"LLM API call failed: {e}")
-            return f"Error: {str(e)}"
-
-class ReactAgent:
-    def __init__(self, llm_client: LLMClient):
-        self.llm_client = llm_client
-        self.web_tools = WebTools()
-        self.system_prompt = """You are a helpful AI assistant with access to web browsing capabilities. You can:
-1. Search the web using DuckDuckGo
-2. Visit and analyze websites
-3. Answer questions based on current information
-
-When a user asks something that requires current information or web searching, use the available tools.
-
-Available tools:
-- search_web(query): Search DuckDuckGo for information
-- visit_website(url): Visit and extract content from a website
-
-Format your tool calls as: TOOL[tool_name: parameters]
-For example: TOOL[search_web: latest news about AI] or TOOL[visit_website: https://example.com]
-
-Always explain what you're doing and provide helpful responses based on the information you gather."""
-
-    def parse_tool_calls(self, text: str) -> List[Dict]:
-        """Parse tool calls from agent response"""
-        tool_pattern = r'TOOL\[(\w+):\s*([^\]]+)\]'
-        matches = re.findall(tool_pattern, text)
-
-        tools = []
-        for tool_name, params in matches:
-            tools.append({
-                'name': tool_name,
-                'params': params.strip()
-            })
-        return tools
-
-    def execute_tool(self, tool_name: str, params: str) -> str:
-        """Execute a tool and return results"""
+            logger.error(f"=== AGENT SETUP ERROR ===")
+            logger.error(f"Failed to setup agent: {e}")
+            import traceback
+            logger.error(f"Traceback: {traceback.format_exc()}")
+            raise e
+
+    def update_config(self, ip: str, port: str, api_key: str, model: str):
+        """Update LLM configuration"""
+        if (ip != self.ip or port != self.port or
+            api_key != self.api_key or model != self.model):
+            self.ip = ip
+            self.port = port
+            self.api_key = api_key
+            self.model = model
+            self._setup_agent()
+
+    def chat(self, message: str, history: List[List[str]]) -> str:
+        """Generate chat response using ReAct agent"""
         try:
-            if tool_name == 'search_web':
-                return self.web_tools.search_web(params)
-            elif tool_name == 'visit_website':
-                return self.web_tools.visit_website(params)
-            else:
-                return f"Unknown tool: {tool_name}"
-        except Exception as e:
-            return f"Tool execution error: {str(e)}"
+            if not self.agent:
+                return "Error: Agent not initialized"
 
-    def process_message(self, message: str, history: List[List[str]], max_tokens: int) -> Generator[str, None, None]:
-        """Process user message with ReAct pattern"""
-        try:
-            # Format chat history
-            messages = [{"role": "system", "content": self.system_prompt}]
+            if ENABLE_DETAILED_LOGGING:
+                logger.info(f"=== USER INPUT ===")
+                logger.info(f"Message: {message}")
+                logger.info(f"History length: {len(history)}")
 
+            # Convert history to messages for context handling
+            messages = []
             for user_msg, assistant_msg in history:
-                messages.append({"role": "user", "content": user_msg})
-                if assistant_msg:
-                    messages.append({"role": "assistant", "content": assistant_msg})
-
-            messages.append({"role": "user", "content": message})
-
-            # Initial LLM call
-            response = self.llm_client.call_llm(messages, max_tokens, stream=True)
-
-            current_response = ""
-            tool_calls_made = False
-
-            # Stream initial response
-            for line in response.iter_lines():
-                if line:
-                    line = line.decode('utf-8')
-                    if line.startswith('data: '):
-                        data_str = line[6:]
-                        if data_str.strip() == '[DONE]':
-                            break
-                        try:
-                            data = json.loads(data_str)
-                            if 'choices' in data and len(data['choices']) > 0:
-                                delta = data['choices'][0].get('delta', {})
-                                content = delta.get('content', '')
-                                if content:
-                                    current_response += content
-                                    yield current_response
-                        except json.JSONDecodeError:
-                            continue
-
-            # Check for tool calls
-            tool_calls = self.parse_tool_calls(current_response)
-
-            if tool_calls:
-                tool_calls_made = True
-                for tool_call in tool_calls:
-                    yield current_response + f"\n\n🔍 Executing {tool_call['name']}..."
-
-                    tool_result = self.execute_tool(tool_call['name'], tool_call['params'])
-
-                    # Add tool result to conversation
-                    messages.append({"role": "assistant", "content": current_response})
-                    messages.append({"role": "user", "content": f"Tool result:\n{tool_result}\n\nPlease provide a helpful response based on this information."})
-
-                    # Get final response
-                    final_response = self.llm_client.call_llm(messages, max_tokens, stream=True)
-
-                    final_text = current_response + f"\n\n**Tool Results:**\n{tool_result}\n\n**Response:**\n"
-
-                    for line in final_response.iter_lines():
-                        if line:
-                            line = line.decode('utf-8')
-                            if line.startswith('data: '):
-                                data_str = line[6:]
-                                if data_str.strip() == '[DONE]':
-                                    break
-                                try:
-                                    data = json.loads(data_str)
-                                    if 'choices' in data and len(data['choices']) > 0:
-                                        delta = data['choices'][0].get('delta', {})
-                                        content = delta.get('content', '')
-                                        if content:
-                                            final_text += content
-                                            yield final_text
-                                except json.JSONDecodeError:
-                                    continue
-                    break  # Only handle first tool call for now
+                messages.append(HumanMessage(content=user_msg))
+                if assistant_msg:  # Only add if assistant responded
+                    from langchain_core.messages import AIMessage
+                    messages.append(AIMessage(content=assistant_msg))
+
+            # Add current message
+            messages.append(HumanMessage(content=message))
+
+            # Invoke the agent
+            if ENABLE_DETAILED_LOGGING:
+                logger.info(f"=== INVOKING AGENT ===")
+                logger.info(f"Total messages in history: {len(messages)}")
+            response = self.agent.invoke({"messages": messages})
+
+            if ENABLE_DETAILED_LOGGING:
+                logger.info(f"=== AGENT RESPONSE ===")
+                logger.info(f"Full response: {response}")
+                logger.info(f"Number of messages: {len(response.get('messages', []))}")
+
+                # Log each message in the response
+                for i, msg in enumerate(response.get("messages", [])):
+                    logger.info(f"Message {i}: Type={type(msg).__name__}, Content={getattr(msg, 'content', 'No content')}")
+
+            # Extract the final response
+            final_message = response["messages"][-1].content
+            if ENABLE_DETAILED_LOGGING:
+                logger.info(f"=== FINAL MESSAGE ===")
+                logger.info(f"Final message: {final_message}")
+
+            return final_message
 
         except Exception as e:
             error_msg = f"Agent error: {str(e)}"
-            logger.error(error_msg)
-            yield error_msg
+            logger.error(f"=== AGENT ERROR ===")
+            logger.error(f"Error: {e}")
+            logger.error(f"Error type: {type(e)}")
+            import traceback
+            logger.error(f"Traceback: {traceback.format_exc()}")
+            return error_msg
 
-# Initialize components
-llm_client = LLMClient(llm_ip, llm_port, llm_key, llm_model)
-agent = ReactAgent(llm_client)
+# Global agent instance
+react_agent = ReactAgentChat(llm_ip, llm_port, llm_key, llm_model)
 
 def generate_response(message: str, history: List[List[str]], system_prompt: str,
                      max_tokens: int, ip: str, port: str, api_key: str, model: str):
-    """Generate streaming response using the agent"""
-    global llm_client, agent
+    """Generate response using ReAct agent"""
+    global react_agent
+
+    try:
+        # Update agent configuration if changed
+        react_agent.update_config(ip, port, api_key, model)
 
-    # Update LLM client if parameters changed
-    if (ip != llm_client.ip or port != llm_client.port or
-        api_key != llm_client.api_key or model != llm_client.model):
-        llm_client = LLMClient(ip, port, api_key, model)
-        agent = ReactAgent(llm_client)
+        # Generate response
+        response = react_agent.chat(message, history)
 
-    # Update system prompt if provided
-    if system_prompt.strip():
-        agent.system_prompt = system_prompt
+        # Stream the response word by word for better UX
+        words = response.split()
+        current_response = ""
+        for word in words:
+            current_response += word + " "
+            yield current_response.strip()
 
-    # Generate response
-    for response in agent.process_message(message, history, max_tokens):
-        yield response
+    except Exception as e:
+        error_msg = f"Error: {str(e)}"
+        logger.error(error_msg)
+        yield error_msg
 
-# Create Gradio interface
+# Create Gradio ChatInterface
 chatbot = gr.ChatInterface(
     generate_response,
     chatbot=gr.Chatbot(
@@ -273,14 +265,14 @@ chatbot = gr.ChatInterface(
     ),
     additional_inputs=[
         gr.Textbox(
-            "You are a helpful AI assistant with web browsing capabilities. You can search the web and visit websites to provide current information. Use TOOL[search_web: query] to search or TOOL[visit_website: url] to browse websites.",
+            "You are a helpful AI assistant with web search capabilities.",
             label="System Prompt",
-            lines=3
+            lines=2
         ),
         gr.Slider(50, 2048, label="Max Tokens", value=512,
                  info="Maximum number of tokens in the response"),
         gr.Textbox(llm_ip, label="LLM IP Address",
-                  info="IP address of the LLM server"),
+                  info="IP address of the OpenAI-compatible LLM server"),
         gr.Textbox(llm_port, label="LLM Port",
                   info="Port of the LLM server"),
         gr.Textbox(llm_key, label="API Key", type="password",
@@ -288,8 +280,8 @@ chatbot = gr.ChatInterface(
         gr.Textbox(llm_model, label="Model Name",
                   info="Name of the model to use"),
     ],
-    title="🤖 AI Agent with Web Browsing",
-    description="Chat with an AI agent that can search the web and browse websites using DuckDuckGo. Use natural language to ask for current information!",
+    title="🤖 LangGraph ReAct Agent with DuckDuckGo Search",
+    description="Chat with a LangGraph ReAct agent that can search the web using DuckDuckGo. Ask about current events, research topics, or any questions that require up-to-date information!",
     theme="finlaymacklon/smooth_slate",
     submit_btn="Send",
     retry_btn="🔄 Regenerate Response",