doc: removed debugging logs

agent_test.py

@@ -22,7 +22,7 @@ class MCPClientWrapper:
     def __init__(self):
         self.session = None
         self.exit_stack = None
-        self.mistral = ChatOpenAI(model_name="mistralai/mistral-small", temperature=0.7, openai_api_key=os.getenv("OPENROUTER_API_KEY"), openai_api_base=os.getenv("OPENROUTER_API_BASE_URL"))
+        self.mistral = ChatOpenAI(model_name="mistralai/mistral-small", temperature=0.7, openai_api_key=os.getenv("OPENROUTER_API_KEY"))
         self.tools = []
     
     def connect(self, server_path: str) -> str:
@@ -191,165 +191,45 @@ class MCPClientWrapper:
 
         return result_messages
 
-    # New methods for image processing
-    def image_to_base64(self, image):
-        """Convert PIL image to base64 string"""
-        if image is None:
-            return None
-        buffered = BytesIO()
-        image.save(buffered, format="PNG")
-        img_str = base64.b64encode(buffered.getvalue()).decode()
-        return img_str
-    
-    async def process_image(self, image, operation, target_format=None, width=None, height=None):
-        """Process an image using MCP tools"""
-        if not self.session:
-            return None, "Please connect to an MCP server first."
-        
-        if image is None:
-            return None, "No image provided."
-
-        try:
-            img_base64 = self.image_to_base64(image)
-            
-            if operation == "Remove Background":
-                result = await self.session.call_tool("remove_background_from_url", {"url": img_base64})
-            
-            elif operation == "Change Format":
-                if not target_format:
-                    return None, "Please select a target format."
-                result = await self.session.call_tool("change_format", {
-                    "image_base64": img_base64, 
-                    "target_format": target_format.lower()
-                })
-            
-            elif operation == "Resize Image":
-                if not width or not height:
-                    return None, "Please provide width and height."
-                result = await self.session.call_tool("resize_image", {
-                    "image_base64": img_base64,
-                    "width": int(width),
-                    "height": int(height)
-                })
-                
-            elif operation == "Visualize Image":
-                result = await self.session.call_tool("visualize_base64_image", {"image_base64": img_base64})
-            
-            else:
-                return None, "Unknown operation."
-            
-            # Process the result
-            result_content = result.content
-            if isinstance(result_content, str):
-                try:
-                    result_data = json.loads(result_content)
-                    if "image_base64" in result_data:
-                        # Convert result base64 back to image
-                        img_data = base64.b64decode(result_data["image_base64"])
-                        result_img = Image.open(BytesIO(img_data))
-                        return result_img, "Image processed successfully."
-                    else:
-                        return None, f"Unexpected result format: {result_content}"
-                except json.JSONDecodeError:
-                    return None, f"Error decoding result: {result_content}"
-            else:
-                return None, f"Unexpected result type: {type(result_content)}"
-                
-        except Exception as e:
-            return None, f"Error processing image: {str(e)}"
-
 client = MCPClientWrapper()
 
 def gradio_interface():
-    with gr.Blocks(title="MCP Assistant") as demo:
-        gr.Markdown("# MCP Assistant")
-        gr.Markdown("Connect to your MCP server to chat or process images")
+    with gr.Blocks(title="MCP Weather Client") as demo:
+        gr.Markdown("# MCP Weather Assistant")
+        gr.Markdown("Connect to your MCP weather server and chat with the assistant")
         
         with gr.Row(equal_height=True):
             with gr.Column(scale=4):
                 server_path = gr.Textbox(
                     label="Server Script Path",
-                    placeholder="Enter path to server script",
-                    value="mcp_server.py"
+                    placeholder="Enter path to server script (e.g., weather.py)",
+                    value="gradio_mcp_server.py"
                 )
             with gr.Column(scale=1):
                 connect_btn = gr.Button("Connect")
         
         status = gr.Textbox(label="Connection Status", interactive=False)
         
-        with gr.Tabs() as tabs:
-            with gr.TabItem("Chat Interface"):
-                chatbot = gr.Chatbot(
-                    value=[], 
-                    height=500,
-                    type="messages",
-                    show_copy_button=True,
-                    avatar_images=("👤", "🤖")
-                )
-                
-                with gr.Row(equal_height=True):
-                    msg = gr.Textbox(
-                        label="Your Question",
-                        placeholder="Ask about the available tools or how to process images",
-                        scale=4
-                    )
-                    clear_btn = gr.Button("Clear Chat", scale=1)
-            
-            with gr.TabItem("Image Processing"):
-                with gr.Row():
-                    with gr.Column():
-                        input_image = gr.Image(label="Input Image", type="pil")
-                        operation = gr.Radio(
-                            ["Remove Background", "Change Format", "Resize Image", "Visualize Image"],
-                            label="Select Operation",
-                            value="Visualize Image"
-                        )
-                        
-                        with gr.Group() as format_options:
-                            target_format = gr.Dropdown(
-                                ["png", "jpeg", "webp"],
-                                label="Target Format",
-                                value="png",
-                                visible=False
-                            )
-                        
-                        with gr.Group() as resize_options:
-                            with gr.Row():
-                                width = gr.Number(label="Width", value=300, visible=False)
-                                height = gr.Number(label="Height", value=300, visible=False)
-                        
-                        process_btn = gr.Button("Process Image")
-                    
-                    with gr.Column():
-                        output_image = gr.Image(label="Processed Image")
-                        output_message = gr.Textbox(label="Status")
+        chatbot = gr.Chatbot(
+            value=[], 
+            height=500,
+            type="messages",
+            show_copy_button=True,
+            avatar_images=("👤", "🤖")
+        )
         
-        # Connect to server
-        connect_btn.click(client.connect, inputs=server_path, outputs=status)
+        with gr.Row(equal_height=True):
+            msg = gr.Textbox(
+                label="Your Question",
+                placeholder="Ask about weather or alerts (e.g., What's the weather in New York?)",
+                scale=4
+            )
+            clear_btn = gr.Button("Clear Chat", scale=1)
         
-        # Chat functionality
+        connect_btn.click(client.connect, inputs=server_path, outputs=status)
         msg.submit(client.process_message, [msg, chatbot], [chatbot, msg])
         clear_btn.click(lambda: [], None, chatbot)
         
-        # Image processing functionality
-        def update_options(op):
-            return {
-                target_format: op == "Change Format",
-                width: op == "Resize Image",
-                height: op == "Resize Image"
-            }
-        
-        operation.change(update_options, inputs=operation, outputs=[target_format, width, height])
-        
-        def process_image_wrapper(image, operation, target_format, width, height):
-            return loop.run_until_complete(client.process_image(image, operation, target_format, width, height))
-        
-        process_btn.click(
-            process_image_wrapper,
-            inputs=[input_image, operation, target_format, width, height],
-            outputs=[output_image, output_message]
-        )
-        
     return demo
 
 if __name__ == "__main__":

gradio_interface/app.py

@@ -13,29 +13,17 @@ from langchain_openai import ChatOpenAI
 from langchain_core.messages import HumanMessage, AIMessage
 from langchain_core.callbacks import StreamingStdOutCallbackHandler
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
 # Load environment
 dotenv_path = os.path.join(os.path.dirname(__file__), '.env')
 load_dotenv(dotenv_path=dotenv_path)
 
-# Debug env
-logger.info(f"OPENROUTER_BASE_URL: {getenv('OPENROUTER_BASE_URL')}")
-logger.info(f"OPENROUTER_API_KEY: {'Found' if getenv('OPENROUTER_API_KEY') else 'Missing'}")
-
 # Connectivity test
 def test_connectivity(url="https://openrouter.helicone.ai/api/v1"):
     try:
         return requests.get(url, timeout=5).status_code == 200
-    except (requests.RequestException, socket.error) as e:
-        logger.error(f"Connectivity test failed: {e}")
+    except (requests.RequestException, socket.error):
         return False
 
-if not test_connectivity():
-    logger.warning("No network to OpenRouter; responses may fail.")
-
 # Helper to make direct API calls to OpenRouter when LangChain fails
 def direct_api_call(messages, api_key, base_url):
     headers = {
@@ -64,7 +52,6 @@ def direct_api_call(messages, api_key, base_url):
         response.raise_for_status()
         return response.json()["choices"][0]["message"]["content"]
     except Exception as e:
-        logger.error(f"Direct API call failed: {e}")
         return f"Error: {str(e)}"
 
 # Initialize LLM with streaming and retry logic
@@ -86,7 +73,6 @@ def init_llm():
 try:
     llm = init_llm()
 except Exception as e:
-    logger.error(f"Failed to initialize LLM: {e}")
     llm = None
 
 # Helpers
@@ -148,7 +134,6 @@ def generate_response(message, chat_history, image):
         # First try with LangChain
         if llm:
             try:
-                # Try streaming first
                 try:
                     stream_iter = llm.stream(lc_messages)
                     partial = ""
@@ -164,7 +149,7 @@ def generate_response(message, chat_history, image):
                     # If we got this far, streaming worked
                     return
                 except Exception as e:
-                    logger.warning(f"Streaming failed: {e}. Falling back to non-streaming mode")
+                    print(f"Streaming failed: {e}. Falling back to non-streaming mode")
                     
                 # Try non-streaming
                 try:
@@ -172,13 +157,10 @@ def generate_response(message, chat_history, image):
                     yield response.content
                     return
                 except Exception as e:
-                    logger.warning(f"Non-streaming LangChain invoke failed: {e}")
                     raise e
             except Exception as e:
-                logger.warning(f"LangChain approach failed: {e}. Trying direct API call")
+                raise e
         
-        # Fallback to direct API call
-        logger.info("Using direct API call as fallback")
         response_text = direct_api_call(
             api_messages,
             getenv("OPENROUTER_API_KEY"),
@@ -189,8 +171,6 @@ def generate_response(message, chat_history, image):
     except Exception as e:
         import traceback
         error_trace = traceback.format_exc()
-        logger.exception(f"All approaches failed during response generation: {e}")
-        logger.error(f"Full traceback: {error_trace}")
         yield f"⚠️ Error al generar respuesta: {str(e)}. Intenta más tarde."
 
 # Gradio interface