Upload 9 files

.huggingface-space

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

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,14 +1,67 @@
----
-title: Nomic
-emoji: 📚
-colorFrom: gray
-colorTo: gray
-sdk: gradio
-sdk_version: 5.30.0
-app_file: app.py
-pinned: false
-license: mit
-short_description: image embedding
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+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
+
+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.
+
+## 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
+
+## 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
+
+## Deployment
+
+This application is designed to be deployed on Huggingface Spaces. To deploy:
+
+1. Create a new Space on Huggingface Spaces with the Gradio SDK
+2. Upload these files to your Space
+3. The Space will automatically build and deploy the application
+
+## Local Development
+
+To run this application locally:
+
+1. Clone this repository
+2. Install the dependencies: `pip install -r requirements.txt`
+3. Run the application: `python app.py`
+4. Open your browser at http://localhost:7860
+
+## Requirements
+
+- Python 3.7+
+- Gradio 4.0+
+- Transformers
+- PyTorch
+- Pillow
+- NumPy
+- Model Context Protocol library
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

app.py

@@ -0,0 +1,232 @@
+import gradio as gr
+import torch
+import numpy as np
+from PIL import Image
+import os
+import json
+import base64
+from io import BytesIO
+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
+    
+    # Convert to PIL Image if needed
+    if not isinstance(image, Image.Image):
+        image = Image.fromarray(image)
+    
+    try:
+        # Generate embedding using the transformers pipeline
+        result = model(image)
+        
+        # Process the result based on its type
+        embedding_list = None
+        
+        # Handle different possible output types
+        if isinstance(result, torch.Tensor):
+            embedding_list = result.detach().cpu().numpy().flatten().tolist()
+        elif isinstance(result, np.ndarray):
+            embedding_list = result.flatten().tolist()
+        elif isinstance(result, list):
+            # If it's a list of tensors or arrays
+            if result and isinstance(result[0], (torch.Tensor, np.ndarray)):
+                embedding_list = result[0].flatten().tolist() if hasattr(result[0], 'flatten') else result[0]
+            else:
+                embedding_list = result
+        else:
+            # Try to convert to a list as a last resort
+            try:
+                if result is not None:
+                    embedding_list = list(result)
+                else:
+                    print("Result is None")
+                    return None
+            except:
+                print(f"Couldn't convert result of type {type(result)} to list")
+                return None
+        
+        # Ensure we have a valid embedding list
+        if embedding_list is None:
+            return None
+            
+        # Calculate embedding dimension
+        embedding_dim = len(embedding_list)
+        
+        return {
+            "embedding": embedding_list,
+            "dimension": embedding_dim
+        }
+    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")
+        
+        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:
+                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()
+
+# Connect the MCP server to the Gradio app
+transport = GradioServerTransport(demo)
+embedding_server.server.connect(transport)
+
+# Launch the Gradio app
+if __name__ == "__main__":
+    demo.launch(mcp_server=True)

app_hf.py

@@ -0,0 +1,222 @@
+import gradio as gr
+import torch
+import numpy as np
+from PIL import Image
+import os
+import json
+import base64
+from io import BytesIO
+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
+    
+    # Convert to PIL Image if needed
+    if not isinstance(image, Image.Image):
+        image = Image.fromarray(image)
+    
+    try:
+        # Generate embedding using the transformers pipeline
+        result = model(image)
+        
+        # Process the result based on its type
+        embedding_list = None
+        
+        # Handle different possible output types
+        if isinstance(result, torch.Tensor):
+            embedding_list = result.detach().cpu().numpy().flatten().tolist()
+        elif isinstance(result, np.ndarray):
+            embedding_list = result.flatten().tolist()
+        elif isinstance(result, list):
+            # If it's a list of tensors or arrays
+            if result and isinstance(result[0], (torch.Tensor, np.ndarray)):
+                embedding_list = result[0].flatten().tolist() if hasattr(result[0], 'flatten') else result[0]
+            else:
+                embedding_list = result
+        else:
+            # Try to convert to a list as a last resort
+            try:
+                if result is not None:
+                    embedding_list = list(result)
+                else:
+                    print("Result is None")
+                    return None
+            except:
+                print(f"Couldn't convert result of type {type(result)} to list")
+                return None
+        
+        # Ensure we have a valid embedding list
+        if embedding_list is None:
+            return None
+            
+        # Calculate embedding dimension
+        embedding_dim = len(embedding_list)
+        
+        return {
+            "embedding": embedding_list,
+            "dimension": embedding_dim
+        }
+    except Exception as e:
+        print(f"Error generating embedding: {str(e)}")
+        return None
+
+# 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)
+
+# Launch the Gradio 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)

example_client.py

@@ -0,0 +1,151 @@
+import requests
+import base64
+from io import BytesIO
+from PIL import Image
+import json
+import matplotlib.pyplot as plt
+import numpy as np
+
+# This is an example client that demonstrates how to use the MCP server
+# 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"
+
+def embed_image_from_url(image_url):
+    """
+    Generate embeddings for an image using the MCP server's embed_image tool
+    
+    Args:
+        image_url: URL of the image to embed
+        
+    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
+
+def embed_image_from_file(image_path):
+    """
+    Generate embeddings for an image using the MCP server's embed_image tool
+    
+    Args:
+        image_path: Path to the image file
+        
+    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
+
+def visualize_embedding(embedding):
+    """
+    Visualize the embedding vector
+    
+    Args:
+        embedding: The embedding vector
+    """
+    # Convert the embedding to a numpy array
+    embedding_array = np.array(embedding)
+    
+    # Plot the embedding
+    plt.figure(figsize=(10, 5))
+    plt.plot(embedding_array)
+    plt.title("Embedding Vector")
+    plt.xlabel("Dimension")
+    plt.ylabel("Value")
+    plt.grid(True)
+    plt.show()
+    
+    # Plot the histogram of the embedding
+    plt.figure(figsize=(10, 5))
+    plt.hist(embedding_array, bins=50)
+    plt.title("Embedding Histogram")
+    plt.xlabel("Value")
+    plt.ylabel("Frequency")
+    plt.grid(True)
+    plt.show()
+
+if __name__ == "__main__":
+    # Example usage with an image URL
+    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)
+    
+    if embedding_data:
+        print(f"Embedding dimension: {embedding_data['dimension']}")
+        print(f"First 10 values of embedding: {embedding_data['embedding'][:10]}...")
+        
+        # Visualize the embedding
+        visualize_embedding(embedding_data['embedding'])
+    
+    # Example usage with a local image file
+    # 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)
+    # 
+    # if embedding_data:
+    #     print(f"Embedding dimension: {embedding_data['dimension']}")
+    #     print(f"First 10 values of embedding: {embedding_data['embedding'][:10]}...")
+    #     
+    #     # Visualize the embedding
+    #     visualize_embedding(embedding_data['embedding'])

requirements.txt

@@ -0,0 +1,9 @@
+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

requirements_hf.txt

@@ -0,0 +1,7 @@
+gradio>=4.0.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

test_local.py

@@ -0,0 +1,97 @@
+import requests
+import base64
+from PIL import Image
+import io
+import json
+import sys
+
+def test_local_server(image_path=None):
+    """
+    Test the local MCP server by sending a request to embed 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"
+    
+    if image_path:
+        # Load the image
+        try:
+            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 with image data
+            mcp_request = {
+                "jsonrpc": "2.0",
+                "method": "callTool",
+                "params": {
+                    "name": "embed_image",
+                    "arguments": {
+                        "image_data": image_base64
+                    }
+                },
+                "id": 1
+            }
+        except Exception as e:
+            print(f"Error loading image: {str(e)}")
+            return
+    else:
+        # Use a test image URL
+        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
+        }
+    
+    print("Sending request to local MCP 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']}")
+            else:
+                # Extract the embedding from the response
+                content = result["result"]["content"][0]["text"]
+                embedding_data = json.loads(content)
+                
+                print("✅ Test successful!")
+                print(f"Embedding dimension: {embedding_data['dimension']}")
+                print(f"First 10 values of embedding: {embedding_data['embedding'][:10]}...")
+        else:
+            print(f"❌ Error: HTTP {response.status_code}")
+            print(response.text)
+    
+    except Exception as e:
+        print(f"❌ Error connecting to server: {str(e)}")
+        print("Make sure the server is running with 'python app.py'")
+
+if __name__ == "__main__":
+    # Check if an image path was provided
+    if len(sys.argv) > 1:
+        image_path = sys.argv[1]
+        print(f"Testing with image: {image_path}")
+        test_local_server(image_path)
+    else:
+        print("No image path provided, using test URL")
+        test_local_server()