mcp_server change

mcp_server.py

@@ -1,4 +1,4 @@
-from mcp.server.fastmcp import FastMCP
+import gradio as gr
 from src.utils.change_format import change_format
 from src.utils.remove_background import remove_background_from_url
 from src.utils.visualize_image import visualize_base64_image
@@ -8,19 +8,208 @@ from src.utils.add_text import add_text_to_image
 from src.utils.watermark import add_watermark, remove_watermark
 from src.utils.describe import describe_image
 from src.utils.compress import compress_image
+import base64
+from PIL import Image
+import io
+import requests
 
-mcp = FastMCP("Youtube Service")
+def image_to_base64(image):
+    if image is None:
+        return None
+    buffer = io.BytesIO()
+    image.save(buffer, format="PNG")
+    return base64.b64encode(buffer.getvalue()).decode()
 
-mcp.add_tool(remove_background_from_url)
-mcp.add_tool(describe_image)
-mcp.add_tool(change_format)
-mcp.add_tool(visualize_base64_image)
-mcp.add_tool(generate_image)
-mcp.add_tool(apply_filter)
-mcp.add_tool(add_text_to_image)
-mcp.add_tool(add_watermark)
-mcp.add_tool(remove_watermark)
-mcp.add_tool(compress_image)
+def base64_to_image(base64_str):
+    if not base64_str:
+        return None
+    image_data = base64.b64decode(base64_str)
+    return Image.open(io.BytesIO(image_data))
+
+def url_to_base64(url):
+    response = requests.get(url)
+    return base64.b64encode(response.content).decode()
+
+def gradio_remove_background(image):
+    if image is None:
+        return None
+    base64_img = image_to_base64(image)
+    result = remove_background_from_url(f"data:image/png;base64,{base64_img}")
+    return base64_to_image(result)
+
+def gradio_describe_image(image):
+    if image is None:
+        return "No image provided"
+    base64_img = image_to_base64(image)
+    return describe_image(base64_img)
+
+def gradio_change_format(image, format_type):
+    if image is None:
+        return None
+    base64_img = image_to_base64(image)
+    result = change_format(base64_img, format_type)
+    return base64_to_image(result)
+
+def gradio_generate_image(prompt, width=512, height=512):
+    result = generate_image(prompt, width, height)
+    return base64_to_image(result)
+
+def gradio_apply_filter(image, filter_type):
+    if image is None:
+        return None
+    base64_img = image_to_base64(image)
+    result = apply_filter(base64_img, filter_type)
+    return base64_to_image(result)
+
+def gradio_add_text(image, text, x=50, y=50, font_size=20, color="white"):
+    if image is None:
+        return None
+    base64_img = image_to_base64(image)
+    result = add_text_to_image(base64_img, text, x, y, font_size, color)
+    return base64_to_image(result)
+
+def gradio_add_watermark(image, watermark_text, opacity=0.5):
+    if image is None:
+        return None
+    base64_img = image_to_base64(image)
+    result = add_watermark(base64_img, watermark_text, opacity)
+    return base64_to_image(result)
+
+def gradio_remove_watermark(image):
+    if image is None:
+        return None
+    base64_img = image_to_base64(image)
+    result = remove_watermark(base64_img)
+    return base64_to_image(result)
+
+def gradio_compress_image(image, quality=80):
+    if image is None:
+        return None
+    base64_img = image_to_base64(image)
+    result = compress_image(base64_img, quality)
+    return base64_to_image(result)
+
+def create_gradio_interface():
+    with gr.Blocks(title="Image Processing Service", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🖼️ Image Processing Service")
+        gr.Markdown("Servicio completo de procesamiento de imágenes")
+        
+        with gr.Tabs():
+            with gr.Tab("🎨 Generate Image"):
+                with gr.Row():
+                    prompt_input = gr.Textbox(label="Prompt", placeholder="Describe the image you want to generate")
+                    with gr.Column():
+                        width_input = gr.Slider(256, 1024, 512, label="Width")
+                        height_input = gr.Slider(256, 1024, 512, label="Height")
+                generate_btn = gr.Button("Generate", variant="primary")
+                generated_output = gr.Image(label="Generated Image")
+                
+                generate_btn.click(
+                    gradio_generate_image,
+                    [prompt_input, width_input, height_input],
+                    generated_output
+                )
+            
+            with gr.Tab("🔍 Describe Image"):
+                with gr.Row():
+                    describe_input = gr.Image(label="Upload Image", type="pil")
+                    description_output = gr.Textbox(label="Description", lines=4)
+                
+                describe_input.change(gradio_describe_image, describe_input, description_output)
+            
+            with gr.Tab("✂️ Remove Background"):
+                with gr.Row():
+                    bg_input = gr.Image(label="Upload Image", type="pil")
+                    bg_output = gr.Image(label="Background Removed")
+                
+                bg_input.change(gradio_remove_background, bg_input, bg_output)
+            
+            with gr.Tab("🎭 Apply Filters"):
+                with gr.Row():
+                    filter_input = gr.Image(label="Upload Image", type="pil")
+                    with gr.Column():
+                        filter_type = gr.Dropdown(
+                            ["blur", "sharpen", "vintage", "black_white", "sepia"],
+                            label="Filter Type",
+                            value="blur"
+                        )
+                        filter_output = gr.Image(label="Filtered Image")
+                
+                filter_input.change(gradio_apply_filter, [filter_input, filter_type], filter_output)
+                filter_type.change(gradio_apply_filter, [filter_input, filter_type], filter_output)
+            
+            with gr.Tab("📝 Add Text"):
+                with gr.Row():
+                    text_input = gr.Image(label="Upload Image", type="pil")
+                    with gr.Column():
+                        text_content = gr.Textbox(label="Text", placeholder="Enter text to add")
+                        with gr.Row():
+                            text_x = gr.Number(label="X Position", value=50)
+                            text_y = gr.Number(label="Y Position", value=50)
+                        with gr.Row():
+                            font_size = gr.Slider(10, 100, 20, label="Font Size")
+                            text_color = gr.ColorPicker(label="Color", value="#FFFFFF")
+                        text_output = gr.Image(label="Image with Text")
+                
+                inputs = [text_input, text_content, text_x, text_y, font_size, text_color]
+                for inp in inputs:
+                    inp.change(gradio_add_text, inputs, text_output)
+            
+            with gr.Tab("💧 Watermark"):
+                with gr.Tabs():
+                    with gr.Tab("Add Watermark"):
+                        with gr.Row():
+                            watermark_input = gr.Image(label="Upload Image", type="pil")
+                            with gr.Column():
+                                watermark_text = gr.Textbox(label="Watermark Text")
+                                watermark_opacity = gr.Slider(0.1, 1.0, 0.5, label="Opacity")
+                                watermark_output = gr.Image(label="Watermarked Image")
+                        
+                        inputs = [watermark_input, watermark_text, watermark_opacity]
+                        for inp in inputs:
+                            inp.change(gradio_add_watermark, inputs, watermark_output)
+                    
+                    with gr.Tab("Remove Watermark"):
+                        with gr.Row():
+                            unwatermark_input = gr.Image(label="Upload Image", type="pil")
+                            unwatermark_output = gr.Image(label="Watermark Removed")
+                        
+                        unwatermark_input.change(gradio_remove_watermark, unwatermark_input, unwatermark_output)
+            
+            with gr.Tab("🗜️ Compress"):
+                with gr.Row():
+                    compress_input = gr.Image(label="Upload Image", type="pil")
+                    with gr.Column():
+                        quality_slider = gr.Slider(10, 100, 80, label="Quality %")
+                        compress_output = gr.Image(label="Compressed Image")
+                
+                compress_input.change(gradio_compress_image, [compress_input, quality_slider], compress_output)
+                quality_slider.change(gradio_compress_image, [compress_input, quality_slider], compress_output)
+            
+            with gr.Tab("🔄 Change Format"):
+                with gr.Row():
+                    format_input = gr.Image(label="Upload Image", type="pil")
+                    with gr.Column():
+                        format_type = gr.Dropdown(
+                            ["PNG", "JPEG", "WEBP", "BMP"],
+                            label="Output Format",
+                            value="PNG"
+                        )
+                        format_output = gr.Image(label="Converted Image")
+                
+                format_input.change(gradio_change_format, [format_input, format_type], format_output)
+                format_type.change(gradio_change_format, [format_input, format_type], format_output)
+        
+        gr.Markdown("---")
+        gr.Markdown("💡 **Status**: Active | Procesamiento de imágenes en tiempo real")
+    
+    return demo
 
 if __name__ == "__main__":
-    mcp.run()
+    demo = create_gradio_interface()
+    demo.launch(
+        server_name="0.0.0.0", 
+        server_port=7860, 
+        share=True,
+        show_error=True
+    )

requirements.txt

@@ -4,4 +4,5 @@ Pillow
 rembg
 onnxruntime
 openai
-opencv-python
+opencv-python
+langchain_openai