Upload 10 files

.gitignore

@@ -0,0 +1,39 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log

.huggingface-space

@@ -1,9 +1,9 @@
-title: Nomic Vision Embedding MCP Server
+title: Nomic Vision Embedding Model
 emoji: 🖼️
 colorFrom: blue
 colorTo: indigo
 sdk: gradio
-sdk_version: 5.26.0
+sdk_version: 4.19.0
 app_file: app_hf.py
 pinned: false
 license: mit

README.md

@@ -1,39 +1,16 @@
----
-title: Nomic MCP Tool
-emoji: 🗂️
-colorFrom: indigo
-colorTo: pink
-sdk: gradio
-sdk_version: "5.26.0"
-app_file: app.py
-pinned: false
----
-# Nomic Vision Embedding MCP Server
+# Nomic Vision Embedding Model
 
-This is a Model Context Protocol (MCP) server for the [nomic-ai/nomic-embed-vision-v1.5](https://huggingface.co/nomic-ai/nomic-embed-vision-v1.5) image embedding model, deployed on Huggingface Spaces using Gradio.
+This project provides a Gradio interface for the [nomic-ai/nomic-embed-vision-v1.5](https://huggingface.co/nomic-ai/nomic-embed-vision-v1.5) image embedding model. It allows you to upload images and generate embeddings that can be used for various computer vision tasks.
 
 ## Features
 
 - Generate embeddings for images using the nomic-ai/nomic-embed-vision-v1.5 model
-- Expose embedding functionality through a Gradio web interface
-- Implement the Model Context Protocol (MCP) to allow integration with MCP clients
+- Simple and intuitive Gradio web interface
+- Support for various image formats
 
 ## How It Works
 
-This application provides two interfaces:
-
-1. **Web Interface**: A Gradio UI that allows users to upload images and view the generated embeddings
-2. **MCP Interface**: An implementation of the Model Context Protocol that exposes the embedding functionality as a tool
-
-## MCP Tool
-
-The server exposes the following MCP tool:
-
-- **embed_image**: Generate embeddings for an image
-  - Input: 
-    - `image_url`: URL of the image to embed, OR
-    - `image_data`: Base64-encoded image data
-  - Output: JSON object containing the embedding vector and its dimension
+The application uses the Hugging Face Transformers library to load the nomic-ai/nomic-embed-vision-v1.5 model and generate embeddings for uploaded images. The embeddings are high-dimensional vector representations of the images that capture their semantic content.
 
 ## Deployment
 
@@ -55,12 +32,12 @@ To run this application locally:
 ## Requirements
 
 - Python 3.7+
-- Gradio 4.0+
+- Gradio 4.19.0+
 - Transformers
 - PyTorch
 - Pillow
 - NumPy
-- Model Context Protocol library
+- Requests
 
 ## License
 

app.py

@@ -10,16 +10,6 @@ import requests
 from typing import Dict, List, Any, Optional
 from transformers.pipelines import pipeline
 
-# MCP imports
-from modelcontextprotocol.server import Server
-from modelcontextprotocol.server.gradio import GradioServerTransport
-from modelcontextprotocol.types import (
-    CallToolRequestSchema,
-    ErrorCode,
-    ListToolsRequestSchema,
-    McpError,
-)
-
 # Initialize the model
 model = pipeline("image-feature-extraction", model="nomic-ai/nomic-embed-vision-v1.5", trust_remote_code=True)
 
@@ -76,157 +66,45 @@ def generate_embedding(image):
     except Exception as e:
         print(f"Error generating embedding: {str(e)}")
         return None
-    
-    return {
-        "embedding": embedding_list,
-        "dimension": embedding_dim
-    }
 
-# Gradio Interface
-with gr.Blocks() as demo:
-    gr.Markdown("# Nomic Vision Embedding Model (nomic-ai/nomic-embed-vision-v1.5)")
-    gr.Markdown("Upload an image to generate embeddings using the Nomic Vision model.")
-    
-    with gr.Row():
-        with gr.Column():
-            input_image = gr.Image(type="pil", label="Input Image")
-            embed_btn = gr.Button("Generate Embedding")
+# Function to generate embeddings from an image URL
+def embed_image_from_url(image_url):
+    try:
+        # Download the image
+        response = requests.get(image_url)
+        image = Image.open(BytesIO(response.content))
         
-        with gr.Column():
-            embedding_json = gr.JSON(label="Embedding Output")
-            embedding_dim = gr.Textbox(label="Embedding Dimension")
-    
-    def update_embedding(img):
-        result = generate_embedding(img)
-        if result is None:
-            return {
-                embedding_json: None,
-                embedding_dim: "No embedding generated"
-            }
-        return {
-            embedding_json: result,
-            embedding_dim: f"Dimension: {len(result['embedding'])}"
-        }
-    
-    embed_btn.click(
-        fn=update_embedding,
-        inputs=[input_image],
-        outputs=[embedding_json, embedding_dim]
-    )
+        # Generate embedding
+        return generate_embedding(image)
+    except Exception as e:
+        return {"error": str(e)}
 
-# MCP Server Implementation
-class NomicEmbeddingServer:
-    def __init__(self):
-        self.server = Server(
-            {
-                "name": "nomic-embedding-server",
-                "version": "0.1.0",
-            },
-            {
-                "capabilities": {
-                    "tools": {},
-                },
-            }
-        )
-        
-        self.setup_tool_handlers()
-        
-        # Error handling
-        self.server.onerror = lambda error: print(f"[MCP Error] {error}")
-    
-    def setup_tool_handlers(self):
-        self.server.set_request_handler(ListToolsRequestSchema, self.handle_list_tools)
-        self.server.set_request_handler(CallToolRequestSchema, self.handle_call_tool)
-    
-    async def handle_list_tools(self, request):
-        return {
-            "tools": [
-                {
-                    "name": "embed_image",
-                    "description": "Generate embeddings for an image using nomic-ai/nomic-embed-vision-v1.5",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "image_url": {
-                                "type": "string",
-                                "description": "URL of the image to embed",
-                            },
-                            "image_data": {
-                                "type": "string",
-                                "description": "Base64-encoded image data (alternative to image_url)",
-                            },
-                        },
-                        "anyOf": [
-                            {"required": ["image_url"]},
-                            {"required": ["image_data"]},
-                        ],
-                    },
-                }
-            ]
-        }
-    
-    async def handle_call_tool(self, request):
-        if request.params.name != "embed_image":
-            raise McpError(
-                ErrorCode.MethodNotFound,
-                f"Unknown tool: {request.params.name}"
-            )
-        
-        args = request.params.arguments
+# Function to generate embeddings from base64 image data
+def embed_image_from_base64(image_data):
+    try:
+        # Decode the base64 image
+        decoded_data = base64.b64decode(image_data)
+        image = Image.open(BytesIO(decoded_data))
         
-        try:
-            # Handle image from URL
-            if "image_url" in args:
-                import requests
-                from io import BytesIO
-                
-                response = requests.get(args["image_url"])
-                image = Image.open(BytesIO(response.content))
-            
-            # Handle image from base64 data
-            elif "image_data" in args:
-                import base64
-                from io import BytesIO
-                
-                image_data = base64.b64decode(args["image_data"])
-                image = Image.open(BytesIO(image_data))
-            
-            else:
-                raise McpError(
-                    ErrorCode.InvalidParams,
-                    "Either image_url or image_data must be provided"
-                )
-            
-            # Generate embedding
-            result = generate_embedding(image)
-            
-            return {
-                "content": [
-                    {
-                        "type": "text",
-                        "text": json.dumps(result, indent=2),
-                    }
-                ]
-            }
-            
-        except Exception as e:
-            return {
-                "content": [
-                    {
-                        "type": "text",
-                        "text": f"Error generating embedding: {str(e)}",
-                    }
-                ],
-                "isError": True,
-            }
-
-# Initialize and run the MCP server
-embedding_server = NomicEmbeddingServer()
+        # Generate embedding
+        return generate_embedding(image)
+    except Exception as e:
+        return {"error": str(e)}
 
-# Connect the MCP server to the Gradio app
-transport = GradioServerTransport(demo)
-embedding_server.server.connect(transport)
+# Create a Gradio app
+app = gr.Interface(
+    fn=generate_embedding,
+    inputs=gr.Image(type="pil", label="Input Image"),
+    outputs=[
+        gr.JSON(label="Embedding Output"),
+        gr.Textbox(label="Embedding Dimension")
+    ],
+    title="Nomic Vision Embedding Model (nomic-ai/nomic-embed-vision-v1.5)",
+    description="Upload an image to generate embeddings using the Nomic Vision model.",
+    examples=[["examples/example1.jpg"], ["examples/example2.jpg"]],
+    allow_flagging="never"
+)
 
-# Launch the Gradio app
+# Launch the app
 if __name__ == "__main__":
-    demo.launch(mcp_server=True)
+    app.launch()

app_hf.py

@@ -10,23 +10,13 @@ import requests
 from typing import Dict, List, Any, Optional
 from transformers.pipelines import pipeline
 
-# MCP imports
-from modelcontextprotocol.server import Server
-from modelcontextprotocol.server.gradio import GradioServerTransport
-from modelcontextprotocol.types import (
-    CallToolRequestSchema,
-    ErrorCode,
-    ListToolsRequestSchema,
-    McpError,
-)
-
 # Initialize the model
 model = pipeline("image-feature-extraction", model="nomic-ai/nomic-embed-vision-v1.5", trust_remote_code=True)
 
 # Function to generate embeddings from an image
 def generate_embedding(image):
     if image is None:
-        return None
+        return None, "No image provided"
     
     # Convert to PIL Image if needed
     if not isinstance(image, Image.Image):
@@ -57,14 +47,14 @@ def generate_embedding(image):
                     embedding_list = list(result)
                 else:
                     print("Result is None")
-                    return None
+                    return None, "Failed to generate embedding"
             except:
                 print(f"Couldn't convert result of type {type(result)} to list")
-                return None
+                return None, "Failed to process embedding"
         
         # Ensure we have a valid embedding list
         if embedding_list is None:
-            return None
+            return None, "Failed to generate embedding"
             
         # Calculate embedding dimension
         embedding_dim = len(embedding_list)
@@ -72,151 +62,25 @@ def generate_embedding(image):
         return {
             "embedding": embedding_list,
             "dimension": embedding_dim
-        }
+        }, f"Dimension: {embedding_dim}"
     except Exception as e:
         print(f"Error generating embedding: {str(e)}")
-        return None
+        return None, f"Error: {str(e)}"
 
-# Gradio Interface
-with gr.Blocks() as demo:
-    gr.Markdown("# Nomic Vision Embedding Model (nomic-ai/nomic-embed-vision-v1.5)")
-    gr.Markdown("Upload an image to generate embeddings using the Nomic Vision model.")
-    
-    with gr.Row():
-        with gr.Column():
-            input_image = gr.Image(type="pil", label="Input Image")
-            embed_btn = gr.Button("Generate Embedding")
-        
-        with gr.Column():
-            embedding_json = gr.JSON(label="Embedding Output")
-            embedding_dim = gr.Textbox(label="Embedding Dimension")
-    
-    def update_embedding(img):
-        result = generate_embedding(img)
-        if result is None:
-            return {
-                embedding_json: None,
-                embedding_dim: "No embedding generated"
-            }
-        return {
-            embedding_json: result,
-            embedding_dim: f"Dimension: {len(result['embedding'])}"
-        }
-    
-    embed_btn.click(
-        fn=update_embedding,
-        inputs=[input_image],
-        outputs=[embedding_json, embedding_dim]
-    )
-
-# MCP Server Implementation
-class NomicEmbeddingServer:
-    def __init__(self):
-        self.server = Server(
-            {
-                "name": "nomic-embedding-server",
-                "version": "0.1.0",
-            },
-            {
-                "capabilities": {
-                    "tools": {},
-                },
-            }
-        )
-        
-        self.setup_tool_handlers()
-        
-        # Error handling
-        self.server.onerror = lambda error: print(f"[MCP Error] {error}")
-    
-    def setup_tool_handlers(self):
-        self.server.set_request_handler(ListToolsRequestSchema, self.handle_list_tools)
-        self.server.set_request_handler(CallToolRequestSchema, self.handle_call_tool)
-    
-    async def handle_list_tools(self, request):
-        return {
-            "tools": [
-                {
-                    "name": "embed_image",
-                    "description": "Generate embeddings for an image using nomic-ai/nomic-embed-vision-v1.5",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "image_url": {
-                                "type": "string",
-                                "description": "URL of the image to embed",
-                            },
-                            "image_data": {
-                                "type": "string",
-                                "description": "Base64-encoded image data (alternative to image_url)",
-                            },
-                        },
-                        "anyOf": [
-                            {"required": ["image_url"]},
-                            {"required": ["image_data"]},
-                        ],
-                    },
-                }
-            ]
-        }
-    
-    async def handle_call_tool(self, request):
-        if request.params.name != "embed_image":
-            raise McpError(
-                ErrorCode.MethodNotFound,
-                f"Unknown tool: {request.params.name}"
-            )
-        
-        args = request.params.arguments
-        
-        try:
-            # Handle image from URL
-            if "image_url" in args:
-                response = requests.get(args["image_url"])
-                image = Image.open(BytesIO(response.content))
-            
-            # Handle image from base64 data
-            elif "image_data" in args:
-                image_data = base64.b64decode(args["image_data"])
-                image = Image.open(BytesIO(image_data))
-            
-            else:
-                raise McpError(
-                    ErrorCode.InvalidParams,
-                    "Either image_url or image_data must be provided"
-                )
-            
-            # Generate embedding
-            result = generate_embedding(image)
-            
-            return {
-                "content": [
-                    {
-                        "type": "text",
-                        "text": json.dumps(result, indent=2),
-                    }
-                ]
-            }
-            
-        except Exception as e:
-            return {
-                "content": [
-                    {
-                        "type": "text",
-                        "text": f"Error generating embedding: {str(e)}",
-                    }
-                ],
-                "isError": True,
-            }
-
-# Initialize and run the MCP server
-embedding_server = NomicEmbeddingServer()
-
-# Connect the MCP server to the Gradio app
-transport = GradioServerTransport(demo)
-embedding_server.server.connect(transport)
+# Create a Gradio app
+app = gr.Interface(
+    fn=generate_embedding,
+    inputs=gr.Image(type="pil", label="Input Image"),
+    outputs=[
+        gr.JSON(label="Embedding Output"),
+        gr.Textbox(label="Embedding Dimension")
+    ],
+    title="Nomic Vision Embedding Model (nomic-ai/nomic-embed-vision-v1.5)",
+    description="Upload an image to generate embeddings using the Nomic Vision model.",
+    allow_flagging="never"
+)
 
-# Launch the Gradio app
+# Launch the app
 if __name__ == "__main__":
     # For Huggingface Spaces, we need to specify the server name and port
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    app.launch(server_name="0.0.0.0", server_port=7860)

example_client.py

@@ -6,13 +6,13 @@ import json
 import matplotlib.pyplot as plt
 import numpy as np
 
-# This is an example client that demonstrates how to use the MCP server
+# This is an example client that demonstrates how to use the Gradio API
 # You would replace this URL with the actual URL of your deployed Huggingface Space
-MCP_SERVER_URL = "https://your-username-nomic-vision-mcp.hf.space/mcp"
+GRADIO_API_URL = "https://your-username-nomic-vision-embedding.hf.space/api/predict"
 
 def embed_image_from_url(image_url):
     """
-    Generate embeddings for an image using the MCP server's embed_image tool
+    Generate embeddings for an image using the Gradio API
     
     Args:
         image_url: URL of the image to embed
@@ -20,38 +20,43 @@ def embed_image_from_url(image_url):
     Returns:
         The embedding vector and its dimension
     """
-    # Prepare the MCP request
-    mcp_request = {
-        "jsonrpc": "2.0",
-        "method": "callTool",
-        "params": {
-            "name": "embed_image",
-            "arguments": {
-                "image_url": image_url
-            }
-        },
-        "id": 1
-    }
-    
-    # Send the request to the MCP server
-    response = requests.post(MCP_SERVER_URL, json=mcp_request)
-    
-    # Parse the response
-    result = response.json()
-    
-    if "error" in result:
-        print(f"Error: {result['error']['message']}")
-        return None
-    
-    # Extract the embedding from the response
-    content = result["result"]["content"][0]["text"]
-    embedding_data = json.loads(content)
-    
-    return embedding_data
+    try:
+        # Download the image
+        response = requests.get(image_url)
+        image = Image.open(BytesIO(response.content))
+        
+        # Convert image to bytes
+        img_byte_arr = BytesIO()
+        image.save(img_byte_arr, format='PNG')
+        img_byte_arr = img_byte_arr.getvalue()
+        
+        # Prepare the request
+        files = {
+            'data': ('image.png', img_byte_arr, 'image/png')
+        }
+        
+        # Send the request to the Gradio API
+        response = requests.post(GRADIO_API_URL, files=files)
+        
+        # Parse the response
+        if response.status_code == 200:
+            result = response.json()
+            embedding_data = result['data'][0]
+            embedding_dim = result['data'][1]
+            
+            return embedding_data, embedding_dim
+        else:
+            print(f"Error: HTTP {response.status_code}")
+            print(response.text)
+            return None, None
+            
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        return None, None
 
 def embed_image_from_file(image_path):
     """
-    Generate embeddings for an image using the MCP server's embed_image tool
+    Generate embeddings for an image using the Gradio API
     
     Args:
         image_path: Path to the image file
@@ -59,41 +64,38 @@ def embed_image_from_file(image_path):
     Returns:
         The embedding vector and its dimension
     """
-    # Load the image
-    with open(image_path, "rb") as f:
-        image_data = f.read()
-    
-    # Encode the image as base64
-    image_base64 = base64.b64encode(image_data).decode("utf-8")
-    
-    # Prepare the MCP request
-    mcp_request = {
-        "jsonrpc": "2.0",
-        "method": "callTool",
-        "params": {
-            "name": "embed_image",
-            "arguments": {
-                "image_data": image_base64
-            }
-        },
-        "id": 1
-    }
-    
-    # Send the request to the MCP server
-    response = requests.post(MCP_SERVER_URL, json=mcp_request)
-    
-    # Parse the response
-    result = response.json()
-    
-    if "error" in result:
-        print(f"Error: {result['error']['message']}")
-        return None
-    
-    # Extract the embedding from the response
-    content = result["result"]["content"][0]["text"]
-    embedding_data = json.loads(content)
-    
-    return embedding_data
+    try:
+        # Load the image
+        image = Image.open(image_path)
+        
+        # Convert image to bytes
+        img_byte_arr = BytesIO()
+        image.save(img_byte_arr, format=image.format if image.format else 'PNG')
+        img_byte_arr = img_byte_arr.getvalue()
+        
+        # Prepare the request
+        files = {
+            'data': ('image.png', img_byte_arr, 'image/png')
+        }
+        
+        # Send the request to the Gradio API
+        response = requests.post(GRADIO_API_URL, files=files)
+        
+        # Parse the response
+        if response.status_code == 200:
+            result = response.json()
+            embedding_data = result['data'][0]
+            embedding_dim = result['data'][1]
+            
+            return embedding_data, embedding_dim
+        else:
+            print(f"Error: HTTP {response.status_code}")
+            print(response.text)
+            return None, None
+            
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        return None, None
 
 def visualize_embedding(embedding):
     """
@@ -128,10 +130,10 @@ if __name__ == "__main__":
     image_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/bert-architects.png"
     print(f"Generating embedding for image: {image_url}")
     
-    embedding_data = embed_image_from_url(image_url)
+    embedding_data, embedding_dim = embed_image_from_url(image_url)
     
     if embedding_data:
-        print(f"Embedding dimension: {embedding_data['dimension']}")
+        print(f"Embedding dimension: {embedding_dim}")
         print(f"First 10 values of embedding: {embedding_data['embedding'][:10]}...")
         
         # Visualize the embedding
@@ -141,10 +143,10 @@ if __name__ == "__main__":
     # Uncomment the following lines to use a local image file
     # image_path = "path/to/your/image.jpg"
     # print(f"Generating embedding for image: {image_path}")
-    # embedding_data = embed_image_from_file(image_path)
+    # embedding_data, embedding_dim = embed_image_from_file(image_path)
     # 
     # if embedding_data:
-    #     print(f"Embedding dimension: {embedding_data['dimension']}")
+    #     print(f"Embedding dimension: {embedding_dim}")
     #     print(f"First 10 values of embedding: {embedding_data['embedding'][:10]}...")
     #     
     #     # Visualize the embedding

requirements.txt

@@ -1,9 +1,7 @@
-transformers
-torch
-pillow
-numpy
-requests
-modelcontextprotocol
-gradio[mcp]
-mcp
-https://gradio-pypi-previews.s3.amazonaws.com/3b5cace94781b90993b596a83fb39fd1584d68ee/gradio-5.26.0-py3-none-any.whl
+transformers>=4.30.0
+torch>=2.0.0
+pillow>=9.0.0
+numpy>=1.20.0
+requests>=2.25.0
+gradio>=4.19.0
+matplotlib>=3.5.0

requirements_hf.txt

@@ -1,7 +1,6 @@
-gradio>=4.0.0
+gradio>=4.19.0
 transformers>=4.30.0
 torch>=2.0.0
 pillow>=9.0.0
 numpy>=1.20.0
-requests>=2.25.0
-modelcontextprotocol>=0.1.0
+requests>=2.25.0

test_local.py

@@ -1,41 +1,37 @@
 import requests
-import base64
 from PIL import Image
 import io
-import json
 import sys
+import json
 
 def test_local_server(image_path=None):
     """
-    Test the local MCP server by sending a request to embed an image
+    Test the local Gradio server by sending a request to generate embeddings for an image
     
     Args:
         image_path: Path to the image file. If None, a test URL will be used.
     """
     # Local server URL (default Gradio port)
-    server_url = "http://localhost:7860/mcp"
+    server_url = "http://localhost:7860/api/predict"
     
     if image_path:
-        # Load the image
         try:
-            with open(image_path, "rb") as f:
-                image_data = f.read()
+            # Load the image
+            image = Image.open(image_path)
             
-            # Encode the image as base64
-            image_base64 = base64.b64encode(image_data).decode("utf-8")
+            # Convert image to bytes
+            img_byte_arr = io.BytesIO()
+            image.save(img_byte_arr, format=image.format if image.format else 'PNG')
+            img_byte_arr = img_byte_arr.getvalue()
             
-            # Prepare the MCP request with image data
-            mcp_request = {
-                "jsonrpc": "2.0",
-                "method": "callTool",
-                "params": {
-                    "name": "embed_image",
-                    "arguments": {
-                        "image_data": image_base64
-                    }
-                },
-                "id": 1
+            # Prepare the request
+            files = {
+                'data': ('image.png', img_byte_arr, 'image/png')
             }
+            
+            # Send the request
+            response = requests.post(server_url, files=files)
+            
         except Exception as e:
             print(f"Error loading image: {str(e)}")
             return
@@ -44,40 +40,44 @@ def test_local_server(image_path=None):
         test_image_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/bert-architects.png"
         print(f"Using test image URL: {test_image_url}")
         
-        # Prepare the MCP request with image URL
-        mcp_request = {
-            "jsonrpc": "2.0",
-            "method": "callTool",
-            "params": {
-                "name": "embed_image",
-                "arguments": {
-                    "image_url": test_image_url
-                }
-            },
-            "id": 1
+        # Download the image
+        response = requests.get(test_image_url)
+        image = Image.open(io.BytesIO(response.content))
+        
+        # Convert image to bytes
+        img_byte_arr = io.BytesIO()
+        image.save(img_byte_arr, format='PNG')
+        img_byte_arr = img_byte_arr.getvalue()
+        
+        # Prepare the request
+        files = {
+            'data': ('image.png', img_byte_arr, 'image/png')
         }
+        
+        # Send the request
+        response = requests.post(server_url, files=files)
     
-    print("Sending request to local MCP server...")
+    print("Sending request to local Gradio server...")
     
     try:
-        # Send the request to the MCP server
-        response = requests.post(server_url, json=mcp_request)
-        
         # Check if the request was successful
         if response.status_code == 200:
             # Parse the response
             result = response.json()
             
             if "error" in result:
-                print(f"Error from server: {result['error']['message']}")
+                print(f"Error from server: {result['error']}")
             else:
                 # Extract the embedding from the response
-                content = result["result"]["content"][0]["text"]
-                embedding_data = json.loads(content)
+                embedding_data = result['data'][0]
+                embedding_dim = result['data'][1]
                 
                 print("✅ Test successful!")
-                print(f"Embedding dimension: {embedding_data['dimension']}")
-                print(f"First 10 values of embedding: {embedding_data['embedding'][:10]}...")
+                print(f"Embedding dimension: {embedding_dim}")
+                if embedding_data:
+                    print(f"First 10 values of embedding: {embedding_data['embedding'][:10]}...")
+                else:
+                    print("No embedding data returned")
         else:
             print(f"❌ Error: HTTP {response.status_code}")
             print(response.text)