mcp-server-milvus 0.1.1.dev0__py3-none-any.whl

mcp_server_milvus/__init__.py

@@ -0,0 +1,8 @@
+from . import server
+
+def main():
+    """Main entry point for the package."""
+    server.main()
+
+# Optionally expose other important items at package level
+__all__ = ['main', 'server']

mcp_server_milvus/blogpost.md

@@ -0,0 +1,18 @@
+We've moved from simple chatbots to sophisticated AI agents that can reason, plan, and execute complex tasks with minimal human intervention. 
+Agents now can perceive their environment, make decisions, and take actions to achieve specific goals, having a particularly big impact on how we build applications. 
+To help with this, the Model Context Protocol (MCP) standard, proposed by Anthropic to standardize how applications provide context to LLMs. It helps building complex workflows on top of LLMs.
+# What is Model Context Protocol (MCP)? 
+MCP is an open protocol that has a goal of standardizing ways to connect AI Models to different data sources and tools.
+The idea is to help you build agents and complex workflows on top of LLMs, making them even smarter. It provides: 
+- A list of pre-built integrations that LLMs can directly plug into
+- The flexibility to switch between LLM providers and vendors 
+The general idea is for MCP to follow a client-server architecture, where a host application can connect to multiple servers: 
+[Image]
+- MCP Hosts: Programs like Claude Desktop, IDEs, or AI tools that want to access data through MCP
+- MCP Clients: Protocol clients that maintain 1:1 connections with servers
+- MCP Servers: Lightweight programs that each expose specific capabilities through the standardized Model Context Protocol
+- Local Data Sources: Your computer’s files, databases, and services that MCP servers can securely access
+- Remote Services: External systems available over the internet (e.g., through APIs) that MCP servers can connect to
+
+# Using Milvus with MCP 
+Milvus, 

mcp_server_milvus/example.env

@@ -0,0 +1,3 @@
+MILVUS_URI=""
+MILVUS_TOKEN=""
+MILVUS_DB=""

mcp_server_milvus/server.py

@@ -0,0 +1,733 @@
+import argparse
+import os
+from contextlib import asynccontextmanager
+from typing import Any, AsyncIterator, Optional
+from dotenv import load_dotenv
+
+from mcp.server.fastmcp import Context, FastMCP
+from pymilvus import DataType, MilvusClient
+
+
+class MilvusConnector:
+    def __init__(
+        self, uri: str, token: Optional[str] = None, db_name: Optional[str] = "default"
+    ):
+        self.uri = uri
+        self.token = token
+        self.client = MilvusClient(uri=uri, token=token, db_name=db_name)
+
+    async def list_collections(self) -> list[str]:
+        """List all collections in the database."""
+        try:
+            return self.client.list_collections()
+        except Exception as e:
+            raise ValueError(f"Failed to list collections: {str(e)}")
+
+    async def get_collection_info(self, collection_name: str) -> dict:
+        """Get detailed information about a collection."""
+        try:
+            return self.client.describe_collection(collection_name)
+        except Exception as e:
+            raise ValueError(f"Failed to get collection info: {str(e)}")
+
+    async def search_collection(
+        self,
+        collection_name: str,
+        query_text: str,
+        limit: int = 5,
+        output_fields: Optional[list[str]] = None,
+        drop_ratio: float = 0.2,
+    ) -> list[dict]:
+        """
+        Perform full text search on a collection.
+
+        Args:
+            collection_name: Name of collection to search
+            query_text: Text to search for
+            limit: Maximum number of results
+            output_fields: Fields to return in results
+            drop_ratio: Proportion of low-frequency terms to ignore (0.0-1.0)
+        """
+        try:
+            search_params = {"params": {"drop_ratio_search": drop_ratio}}
+
+            results = self.client.search(
+                collection_name=collection_name,
+                data=[query_text],
+                anns_field="sparse",
+                limit=limit,
+                output_fields=output_fields,
+                search_params=search_params,
+            )
+            return results
+        except Exception as e:
+            raise ValueError(f"Search failed: {str(e)}")
+
+    async def query_collection(
+        self,
+        collection_name: str,
+        filter_expr: str,
+        output_fields: Optional[list[str]] = None,
+        limit: int = 10,
+    ) -> list[dict]:
+        """Query collection using filter expressions."""
+        try:
+            return self.client.query(
+                collection_name=collection_name,
+                filter=filter_expr,
+                output_fields=output_fields,
+                limit=limit,
+            )
+        except Exception as e:
+            raise ValueError(f"Query failed: {str(e)}")
+
+    async def vector_search(
+        self,
+        collection_name: str,
+        vector: list[float],
+        vector_field: str,
+        limit: int = 5,
+        output_fields: Optional[list[str]] = None,
+        metric_type: str = "COSINE",
+    ) -> list[dict]:
+        """
+        Perform vector similarity search on a collection.
+
+        Args:
+            collection_name: Name of collection to search
+            vector: Query vector
+            vector_field: Field containing vectors to search
+            limit: Maximum number of results
+            output_fields: Fields to return in results
+            metric_type: Distance metric (COSINE, L2, IP)
+            filter_expr: Optional filter expression
+        """
+        try:
+            search_params = {"metric_type": metric_type, "params": {"nprobe": 10}}
+
+            results = self.client.search(
+                collection_name=collection_name,
+                data=[vector],
+                anns_field=vector_field,
+                search_params=search_params,
+                limit=limit,
+                output_fields=output_fields,
+
+            )
+            return results
+        except Exception as e:
+            raise ValueError(f"Vector search failed: {str(e)}")
+
+    async def hybrid_search(
+        self,
+        collection_name: str,
+        vector: list[float],
+        vector_field: str,
+        limit: int = 5,
+        output_fields: Optional[list[str]] = None,
+        metric_type: str = "COSINE",
+    ) -> list[dict]:
+        """
+        Perform hybrid search combining vector similarity and attribute filtering.
+
+        Args:
+            collection_name: Name of collection to search
+            vector: Query vector
+            vector_field: Field containing vectors to search
+            filter_expr: Filter expression for metadata
+            limit: Maximum number of results
+            output_fields: Fields to return in results
+            metric_type: Distance metric (COSINE, L2, IP)
+        """
+        raise NotImplementedError('This method is not yet supported.') 
+
+    async def create_collection(
+        self,
+        collection_name: str,
+        schema: dict[str, Any],
+        index_params: Optional[dict[str, Any]] = None,
+    ) -> bool:
+        """
+        Create a new collection with the specified schema.
+
+        Args:
+            collection_name: Name for the new collection
+            schema: Collection schema definition
+            index_params: Optional index parameters
+        """
+        try:
+            # Check if collection already exists
+            if collection_name in self.client.list_collections():
+                raise ValueError(f"Collection '{collection_name}' already exists")
+
+            # Create collection
+            self.client.create_collection(
+                collection_name=collection_name,
+                dimension=schema.get("dimension", 128),
+                primary_field=schema.get("primary_field", "id"),
+                id_type=schema.get("id_type", DataType.INT64),
+                vector_field=schema.get("vector_field", "vector"),
+                metric_type=schema.get("metric_type", "COSINE"),
+                auto_id=schema.get("auto_id", False),
+                enable_dynamic_field=schema.get("enable_dynamic_field", True),
+                other_fields=schema.get("other_fields", []),
+            )
+
+            # Create index if params provided
+            if index_params:
+                self.client.create_index(
+                    collection_name=collection_name,
+                    field_name=schema.get("vector_field", "vector"),
+                    index_params=index_params,
+                )
+
+            return True
+        except Exception as e:
+            raise ValueError(f"Failed to create collection: {str(e)}")
+
+    async def insert_data(
+        self, collection_name: str, data: dict[str, list[Any]]
+    ) -> dict[str, Any]:
+        """
+        Insert data into a collection.
+
+        Args:
+            collection_name: Name of collection
+            data: Dictionary mapping field names to lists of values
+        """
+        try:
+            result = self.client.insert(collection_name=collection_name, data=data)
+            return result
+        except Exception as e:
+            raise ValueError(f"Insert failed: {str(e)}")
+
+    async def delete_entities(
+        self, collection_name: str, filter_expr: str
+    ) -> dict[str, Any]:
+        """
+        Delete entities from a collection based on filter expression.
+
+        Args:
+            collection_name: Name of collection
+            filter_expr: Filter expression to select entities to delete
+        """
+        try:
+            result = self.client.delete(
+                collection_name=collection_name, expr=filter_expr
+            )
+            return result
+        except Exception as e:
+            raise ValueError(f"Delete failed: {str(e)}")
+
+    async def get_collection_stats(self, collection_name: str) -> dict[str, Any]:
+        """
+        Get statistics about a collection.
+
+        Args:
+            collection_name: Name of collection
+        """
+        try:
+            return self.client.get_collection_stats(collection_name)
+        except Exception as e:
+            raise ValueError(f"Failed to get collection stats: {str(e)}")
+
+    async def multi_vector_search(
+        self,
+        collection_name: str,
+        vectors: list[list[float]],
+        vector_field: str,
+        limit: int = 5,
+        output_fields: Optional[list[str]] = None,
+        metric_type: str = "COSINE",
+        search_params: Optional[dict[str, Any]] = None,
+    ) -> list[list[dict]]:
+        """
+        Perform vector similarity search with multiple query vectors.
+
+        Args:
+            collection_name: Name of collection to search
+            vectors: List of query vectors
+            vector_field: Field containing vectors to search
+            limit: Maximum number of results per query
+            output_fields: Fields to return in results
+            metric_type: Distance metric (COSINE, L2, IP)
+            filter_expr: Optional filter expression
+            search_params: Additional search parameters
+        """
+        try:
+            if search_params is None:
+                search_params = {"metric_type": metric_type, "params": {"nprobe": 10}}
+
+            results = self.client.search(
+                collection_name=collection_name,
+                data=vectors,
+                anns_field=vector_field,
+                search_params=search_params,
+                limit=limit,
+                output_fields=output_fields,
+            )
+            return results
+        except Exception as e:
+            raise ValueError(f"Multi-vector search failed: {str(e)}")
+
+    async def create_index(
+        self,
+        collection_name: str,
+        field_name: str,
+        index_type: str = "IVF_FLAT",
+        metric_type: str = "COSINE",
+        params: Optional[dict[str, Any]] = None,
+    ) -> bool:
+        """
+        Create an index on a vector field.
+
+        Args:
+            collection_name: Name of collection
+            field_name: Field to index
+            index_type: Type of index (IVF_FLAT, HNSW, etc.)
+            metric_type: Distance metric (COSINE, L2, IP)
+            params: Additional index parameters
+        """
+        try:
+            if params is None:
+                params = {"nlist": 1024}
+
+            index_params = {
+                "index_type": index_type,
+                "metric_type": metric_type,
+                "params": params,
+            }
+
+            self.client.create_index(
+                collection_name=collection_name,
+                field_name=field_name,
+                index_params=index_params,
+            )
+            return True
+        except Exception as e:
+            raise ValueError(f"Failed to create index: {str(e)}")
+
+    async def bulk_insert(
+        self, collection_name: str, data: dict[str, list[Any]], batch_size: int = 1000
+    ) -> list[dict[str, Any]]:
+        """
+        Insert data in batches for better performance.
+
+        Args:
+            collection_name: Name of collection
+            data: Dictionary mapping field names to lists of values
+            batch_size: Number of records per batch
+        """
+        try:
+            results = []
+            field_names = list(data.keys())
+            total_records = len(data[field_names[0]])
+
+            for i in range(0, total_records, batch_size):
+                batch_data = {
+                    field: data[field][i : i + batch_size] for field in field_names
+                }
+
+                result = self.client.insert(
+                    collection_name=collection_name, data=batch_data
+                )
+                results.append(result)
+
+            return results
+        except Exception as e:
+            raise ValueError(f"Bulk insert failed: {str(e)}")
+
+    async def load_collection(
+        self, collection_name: str, replica_number: int = 1
+    ) -> bool:
+        """
+        Load a collection into memory for search and query.
+
+        Args:
+            collection_name: Name of collection to load
+            replica_number: Number of replicas
+        """
+        try:
+            self.client.load_collection(
+                collection_name=collection_name, replica_number=replica_number
+            )
+            return True
+        except Exception as e:
+            raise ValueError(f"Failed to load collection: {str(e)}")
+
+    async def release_collection(self, collection_name: str) -> bool:
+        """
+        Release a collection from memory.
+
+        Args:
+            collection_name: Name of collection to release
+        """
+        try:
+            self.client.release_collection(collection_name=collection_name)
+            return True
+        except Exception as e:
+            raise ValueError(f"Failed to release collection: {str(e)}")
+
+    async def get_query_segment_info(self, collection_name: str) -> dict[str, Any]:
+        """
+        Get information about query segments.
+
+        Args:
+            collection_name: Name of collection
+        """
+        try:
+            return self.client.get_query_segment_info(collection_name)
+        except Exception as e:
+            raise ValueError(f"Failed to get query segment info: {str(e)}")
+
+    async def upsert_data(
+        self, collection_name: str, data: dict[str, list[Any]]
+    ) -> dict[str, Any]:
+        """
+        Upsert data into a collection (insert or update if exists).
+
+        Args:
+            collection_name: Name of collection
+            data: Dictionary mapping field names to lists of values
+        """
+        try:
+            result = self.client.upsert(collection_name=collection_name, data=data)
+            return result
+        except Exception as e:
+            raise ValueError(f"Upsert failed: {str(e)}")
+
+    async def get_index_info(
+        self, collection_name: str, field_name: Optional[str] = None
+    ) -> dict[str, Any]:
+        """
+        Get information about indexes in a collection.
+
+        Args:
+            collection_name: Name of collection
+            field_name: Optional specific field to get index info for
+        """
+        try:
+            return self.client.describe_index(
+                collection_name=collection_name, index_name=field_name
+            )
+        except Exception as e:
+            raise ValueError(f"Failed to get index info: {str(e)}")
+
+    async def get_collection_loading_progress(
+        self, collection_name: str
+    ) -> dict[str, Any]:
+        """
+        Get the loading progress of a collection.
+
+        Args:
+            collection_name: Name of collection
+        """
+        try:
+            return self.client.get_load_state(collection_name)
+        except Exception as e:
+            raise ValueError(f"Failed to get loading progress: {str(e)}")
+        
+    async def list_databases(self) -> list[str]:
+        """List all databases in the Milvus instance."""
+        try:
+            return self.client.list_databases()
+        except Exception as e:
+            raise ValueError(f"Failed to list databases: {str(e)}")
+
+    async def use_database(self, db_name: str) -> bool:
+        """Switch to a different database.
+        
+        Args:
+            db_name: Name of the database to use
+        """
+        try:
+            # Create a new client with the specified database
+            self.client = MilvusClient(
+                uri=self.uri, 
+                token=self.token, 
+                db_name=db_name
+            )
+            return True
+        except Exception as e:
+            raise ValueError(f"Failed to switch database: {str(e)}")
+
+
+class MilvusContext:
+    def __init__(self, connector: MilvusConnector):
+        self.connector = connector
+
+
+@asynccontextmanager
+async def server_lifespan(server: FastMCP) -> AsyncIterator[MilvusContext]:
+    """Manage application lifecycle for Milvus connector."""
+    config = server.config
+
+    connector = MilvusConnector(
+        uri=config.get("milvus_uri", "http://localhost:19530"),
+        token=config.get("milvus_token"),
+        db_name=config.get("db_name", "default"),
+    )
+
+    try:
+        yield MilvusContext(connector)
+    finally:
+        pass
+
+
+mcp = FastMCP("Milvus", lifespan=server_lifespan)
+
+
+@mcp.tool()
+async def milvus_text_search(
+    collection_name: str,
+    query_text: str,
+    limit: int = 5,
+    output_fields: Optional[list[str]] = None,
+    drop_ratio: float = 0.2,
+    ctx: Context = None,
+) -> str:
+    """
+    Search for documents using full text search in a Milvus collection.
+
+    Args:
+        collection_name: Name of the collection to search
+        query_text: Text to search for
+        limit: Maximum number of results to return
+        output_fields: Fields to include in results
+        drop_ratio: Proportion of low-frequency terms to ignore (0.0-1.0)
+    """
+    connector = ctx.request_context.lifespan_context.connector
+    results = await connector.search_collection(
+        collection_name=collection_name,
+        query_text=query_text,
+        limit=limit,
+        output_fields=output_fields,
+        drop_ratio=drop_ratio,
+    )
+
+    output = f"Search results for '{query_text}' in collection '{collection_name}':\n\n"
+    for result in results:
+        output += f"{result}\n\n"
+
+    return output
+
+
+@mcp.tool()
+async def milvus_list_collections(ctx: Context) -> str:
+    """List all collections in the database."""
+    connector = ctx.request_context.lifespan_context.connector
+    collections = await connector.list_collections()
+    return f"Collections in database:\n{', '.join(collections)}"
+
+
+@mcp.tool()
+async def milvus_query(
+    collection_name: str,
+    filter_expr: str,
+    output_fields: Optional[list[str]] = None,
+    limit: int = 10,
+    ctx: Context = None,
+) -> str:
+    """
+    Query collection using filter expressions.
+
+    Args:
+        collection_name: Name of the collection to query
+        filter_expr: Filter expression (e.g. 'age > 20')
+        output_fields: Fields to include in results
+        limit: Maximum number of results
+    """
+    connector = ctx.request_context.lifespan_context.connector
+    results = await connector.query_collection(
+        collection_name=collection_name,
+        filter_expr=filter_expr,
+        output_fields=output_fields,
+        limit=limit,
+    )
+
+    output = f"Query results for '{filter_expr}' in collection '{collection_name}':\n\n"
+    for result in results:
+        output += f"{result}\n\n"
+
+    return output
+
+
+@mcp.tool()
+async def milvus_vector_search(
+    collection_name: str,
+    vector: list[float],
+    vector_field: str = "vector",
+    limit: int = 5,
+    output_fields: Optional[list[str]] = None,
+    metric_type: str = "COSINE",
+    filter_expr: Optional[str] = None,
+    ctx: Context = None,
+) -> str:
+    """
+    Perform vector similarity search on a collection.
+
+    Args:
+        collection_name: Name of the collection to search
+        vector: Query vector
+        vector_field: Field containing vectors to search
+        limit: Maximum number of results
+        output_fields: Fields to include in results
+        metric_type: Distance metric (COSINE, L2, IP)
+        filter_expr: Optional filter expression
+    """
+    connector = ctx.request_context.lifespan_context.connector
+    results = await connector.vector_search(
+        collection_name=collection_name,
+        vector=vector,
+        vector_field=vector_field,
+        limit=limit,
+        output_fields=output_fields,
+        metric_type=metric_type,
+        filter_expr=filter_expr,
+    )
+
+    output = f"Vector search results for '{collection_name}':\n\n"
+    for result in results:
+        output += f"{result}\n\n"
+
+    return output
+
+
+@mcp.tool()
+async def milvus_create_collection(
+    collection_name: str,
+    collection_schema: dict[str, Any],
+    index_params: Optional[dict[str, Any]] = None,
+    ctx: Context = None,
+) -> str:
+    """
+    Create a new collection with specified schema.
+
+    Args:
+        collection_name: Name for the new collection
+        collection_schema: Collection schema definition
+        index_params: Optional index parameters
+    """
+    connector = ctx.request_context.lifespan_context.connector
+    success = await connector.create_collection(
+        collection_name=collection_name,
+        schema=collection_schema,
+        index_params=index_params,
+    )
+
+    return f"Collection '{collection_name}' created successfully"
+
+
+@mcp.tool()
+async def milvus_insert_data(
+    collection_name: str, data: dict[str, list[Any]], ctx: Context = None
+) -> str:
+    """
+    Insert data into a collection.
+
+    Args:
+        collection_name: Name of collection
+        data: Dictionary mapping field names to lists of values
+    """
+    connector = ctx.request_context.lifespan_context.connector
+    result = await connector.insert_data(collection_name=collection_name, data=data)
+
+    return (
+        f"Data inserted into collection '{collection_name}' with result: {str(result)}"
+    )
+
+
+@mcp.tool()
+async def milvus_delete_entities(
+    collection_name: str, filter_expr: str, ctx: Context = None
+) -> str:
+    """
+    Delete entities from a collection based on filter expression.
+
+    Args:
+        collection_name: Name of collection
+        filter_expr: Filter expression to select entities to delete
+    """
+    connector = ctx.request_context.lifespan_context.connector
+    result = await connector.delete_entities(
+        collection_name=collection_name, filter_expr=filter_expr
+    )
+
+    return f"Entities deleted from collection '{collection_name}' with result: {str(result)}"
+
+
+@mcp.tool()
+async def milvus_load_collection(
+    collection_name: str, replica_number: int = 1, ctx: Context = None
+) -> str:
+    """
+    Load a collection into memory for search and query.
+
+    Args:
+        collection_name: Name of collection to load
+        replica_number: Number of replicas
+    """
+    connector = ctx.request_context.lifespan_context.connector
+    success = await connector.load_collection(
+        collection_name=collection_name, replica_number=replica_number
+    )
+
+    return f"Collection '{collection_name}' loaded successfully with {replica_number} replica(s)"
+
+
+@mcp.tool()
+async def milvus_release_collection(collection_name: str, ctx: Context = None) -> str:
+    """
+    Release a collection from memory.
+
+    Args:
+        collection_name: Name of collection to release
+    """
+    connector = ctx.request_context.lifespan_context.connector
+    success = await connector.release_collection(collection_name=collection_name)
+
+    return f"Collection '{collection_name}' released successfully"
+
+
+@mcp.tool()
+async def milvus_list_databases(ctx: Context = None) -> str:
+    """List all databases in the Milvus instance."""
+    connector = ctx.request_context.lifespan_context.connector
+    databases = await connector.list_databases()
+    return f"Databases in Milvus instance:\n{', '.join(databases)}"
+
+
+@mcp.tool()
+async def milvus_use_database(db_name: str, ctx: Context = None) -> str:
+    """
+    Switch to a different database.
+    
+    Args:
+        db_name: Name of the database to use
+    """
+    connector = ctx.request_context.lifespan_context.connector
+    success = await connector.use_database(db_name)
+    
+    return f"Switched to database '{db_name}' successfully"
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(description="Milvus MCP Server")
+    parser.add_argument("--milvus-uri", type=str,
+                        default="http://localhost:19530", help="Milvus server URI")
+    parser.add_argument("--milvus-token", type=str,
+                        default=None, help="Milvus authentication token")
+    parser.add_argument("--milvus-db", type=str,
+                        default="default", help="Milvus database name")
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    load_dotenv()
+    args = parse_arguments()
+    mcp.config = {
+        "milvus_uri": os.environ.get("MILVUS_URI", args.milvus_uri),
+        "milvus_token": os.environ.get("MILVUS_TOKEN", args.milvus_token),
+        "db_name": os.environ.get("MILVUS_DB", args.milvus_db),
+    }
+
+    mcp.run()

mcp_server_milvus-0.1.1.dev0.dist-info/METADATA

@@ -0,0 +1,330 @@
+Metadata-Version: 2.4
+Name: mcp-server-milvus
+Version: 0.1.1.dev0
+Summary: MCP server for Milvus
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0.0
+Requires-Dist: dotenv>=0.9.9
+Requires-Dist: mcp[cli]>=1.1.2
+Requires-Dist: pymilvus>=2.5.1
+Requires-Dist: ruff>=0.11.0
+Description-Content-Type: text/markdown
+
+# MCP Server for Milvus
+
+> The Model Context Protocol (MCP) is an open protocol that enables seamless integration between LLM applications and external data sources and tools. Whether you're building an AI-powered IDE, enhancing a chat interface, or creating custom AI workflows, MCP provides a standardized way to connect LLMs with the context they need.
+
+This repository contains a MCP server that provides access to [Milvus](https://milvus.io/) vector database functionality.
+
+![MCP with Milvus](Claude_mcp+1080.gif)
+
+## Prerequisites
+
+Before using this MCP server, ensure you have:
+
+- Python 3.10 or higher
+- A running [Milvus](https://milvus.io/) instance (local or remote)
+- [uv](https://github.com/astral-sh/uv) installed (recommended for running the server)
+
+## Usage
+
+The recommended way to use this MCP server is to run it directly with `uv` without installation. This is how both Claude Desktop and Cursor are configured to use it in the examples below.
+
+If you want to clone the repository:
+
+```bash
+git clone https://github.com/zilliztech/mcp-server-milvus.git
+cd mcp-server-milvus
+```
+
+Then you can run the server directly:
+
+```bash
+uv run src/mcp_server_milvus/server.py --milvus-uri http://localhost:19530
+```
+
+Alternatively you can change the .env file in the `src/mcp_server_milvus/` directory to set the environment variables and run the server with the following command:
+
+```bash
+uv run src/mcp_server_milvus/server.py
+```
+
+### Important: the .env file will have higher priority than the command line arguments.
+
+## Supported Applications
+
+This MCP server can be used with various LLM applications that support the Model Context Protocol:
+
+- **Claude Desktop**: Anthropic's desktop application for Claude
+- **Cursor**: AI-powered code editor with MCP support
+- **Custom MCP clients**: Any application implementing the MCP client specification
+
+## Usage with Claude Desktop
+
+1. Install Claude Desktop from https://claude.ai/download
+2. Open your Claude Desktop configuration:
+
+   - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+
+3. Add the following configuration:
+
+```json
+{
+  "mcpServers": {
+    "milvus": {
+      "command": "/PATH/TO/uv",
+      "args": [
+        "--directory",
+        "/path/to/mcp-server-milvus/src/mcp_server_milvus",
+        "run",
+        "server.py",
+        "--milvus-uri",
+        "http://localhost:19530"
+      ]
+    }
+  }
+}
+```
+
+4. Restart Claude Desktop
+
+## Usage with Cursor
+
+[Cursor also supports MCP](https://docs.cursor.com/context/model-context-protocol) tools. You can add the Milvus MCP server to Cursor in two ways:
+
+### Option 1: Using Cursor Settings UI
+
+1. Go to `Cursor Settings` > `Features` > `MCP`
+2. Click on the `+ Add New MCP Server` button
+3. Fill out the form:
+
+   - **Type**: Select `stdio` (since you're running a command)
+   - **Name**: `milvus`
+   - **Command**: `/PATH/TO/uv --directory /path/to/mcp-server-milvus/src/mcp_server_milvus run server.py --milvus-uri http://127.0.0.1:19530`
+
+   > ⚠️ Note: Use `127.0.0.1` instead of `localhost` to avoid potential DNS resolution issues.
+
+### Option 2: Using Project-specific Configuration (Recommended)
+
+Create a `.cursor/mcp.json` file in your project root:
+
+1. Create the `.cursor` directory in your project root:
+
+   ```bash
+   mkdir -p /path/to/your/project/.cursor
+   ```
+
+2. Create a `mcp.json` file with the following content:
+
+   ```json
+   {
+     "mcpServers": {
+       "milvus": {
+         "command": "/PATH/TO/uv",
+         "args": [
+           "--directory",
+           "/path/to/mcp-server-milvus/src/mcp_server_milvus",
+           "run",
+           "server.py",
+           "--milvus-uri",
+           "http://127.0.0.1:19530"
+         ]
+       }
+     }
+   }
+   ```
+
+3. Restart Cursor or reload the window
+
+After adding the server, you may need to press the refresh button in the MCP settings to populate the tool list. The Agent will automatically use the Milvus tools when relevant to your queries.
+
+### Verifying the Integration
+
+To verify that Cursor has successfully integrated with your Milvus MCP server:
+
+1. Open Cursor Settings > Features > MCP
+2. Check that "Milvus" appears in the list of MCP servers
+3. Verify that the tools are listed (e.g., milvus_list_collections, milvus_vector_search, etc.)
+4. If the server is enabled but shows an error, check the Troubleshooting section below
+
+## Available Tools
+
+The server provides the following tools:
+
+### Search and Query Operations
+
+- `milvus_text_search`: Search for documents using full text search
+
+  - Parameters:
+    - `collection_name`: Name of collection to search
+    - `query_text`: Text to search for
+    - `limit`: Maximum results (default: 5)
+    - `output_fields`: Fields to include in results
+    - `drop_ratio`: Proportion of low-frequency terms to ignore (0.0-1.0)
+
+- `milvus_vector_search`: Perform vector similarity search on a collection
+
+  - Parameters:
+    - `collection_name`: Name of collection to search
+    - `vector`: Query vector
+    - `vector_field`: Field containing vectors to search (default: "vector")
+    - `limit`: Maximum results (default: 5)
+    - `output_fields`: Fields to include in results
+    - `metric_type`: Distance metric (COSINE, L2, IP) (default: "COSINE")
+
+- `milvus_query`: Query collection using filter expressions
+  - Parameters:
+    - `collection_name`: Name of collection to query
+    - `filter_expr`: Filter expression (e.g. 'age > 20')
+    - `output_fields`: Fields to include in results
+    - `limit`: Maximum results (default: 10)
+
+### Collection Management
+
+- `milvus_list_collections`: List all collections in the database
+
+- `milvus_create_collection`: Create a new collection with specified schema
+
+  - Parameters:
+    - `collection_name`: Name for the new collection
+    - `collection_schema`: Collection schema definition
+    - `index_params`: Optional index parameters
+
+- `milvus_load_collection`: Load a collection into memory for search and query
+
+  - Parameters:
+    - `collection_name`: Name of collection to load
+    - `replica_number`: Number of replicas (default: 1)
+
+- `milvus_release_collection`: Release a collection from memory
+  - Parameters:
+    - `collection_name`: Name of collection to release
+
+### Data Operations
+
+- `milvus_insert_data`: Insert data into a collection
+
+  - Parameters:
+    - `collection_name`: Name of collection
+    - `data`: Dictionary mapping field names to lists of values
+
+- `milvus_delete_entities`: Delete entities from a collection based on filter expression
+  - Parameters:
+    - `collection_name`: Name of collection
+    - `filter_expr`: Filter expression to select entities to delete
+
+## Environment Variables
+
+- `MILVUS_URI`: Milvus server URI (can be set instead of --milvus-uri)
+- `MILVUS_TOKEN`: Optional authentication token
+- `MILVUS_DB`: Database name (defaults to "default")
+
+## Development
+
+To run the server directly:
+
+```bash
+uv run server.py --milvus-uri http://localhost:19530
+```
+
+## Examples
+
+### Using Claude Desktop
+
+#### Example 1: Listing Collections
+
+```
+What are the collections I have in my Milvus DB?
+```
+
+Claude will then use MCP to check this information on your Milvus DB.
+
+```
+I'll check what collections are available in your Milvus database.
+
+Here are the collections in your Milvus database:
+
+1. rag_demo
+2. test
+3. chat_messages
+4. text_collection
+5. image_collection
+6. customized_setup
+7. streaming_rag_demo
+```
+
+#### Example 2: Searching for Documents
+
+```
+Find documents in my text_collection that mention "machine learning"
+```
+
+Claude will use the full-text search capabilities of Milvus to find relevant documents:
+
+```
+I'll search for documents about machine learning in your text_collection.
+
+> View result from milvus-text-search from milvus (local)
+
+Here are the documents I found that mention machine learning:
+[Results will appear here based on your actual data]
+```
+
+### Using Cursor
+
+#### Example: Creating a Collection
+
+In Cursor, you can ask:
+
+```
+Create a new collection called 'articles' in Milvus with fields for title (string), content (string), and a vector field (128 dimensions)
+```
+
+Cursor will use the MCP server to execute this operation:
+
+```
+I'll create a new collection called 'articles' with the specified fields.
+
+Collection 'articles' has been created successfully with the following schema:
+- title: string
+- content: string
+- vector: float vector[128]
+```
+
+## Troubleshooting
+
+### Common Issues
+
+#### Connection Errors
+
+If you see errors like "Failed to connect to Milvus server":
+
+1. Verify your Milvus instance is running: `docker ps` (if using Docker)
+2. Check the URI is correct in your configuration
+3. Ensure there are no firewall rules blocking the connection
+4. Try using `127.0.0.1` instead of `localhost` in the URI
+
+#### Authentication Issues
+
+If you see authentication errors:
+
+1. Verify your `MILVUS_TOKEN` is correct
+2. Check if your Milvus instance requires authentication
+3. Ensure you have the correct permissions for the operations you're trying to perform
+
+#### Tool Not Found
+
+If the MCP tools don't appear in Claude Desktop or Cursor:
+
+1. Restart the application
+2. Check the server logs for any errors
+3. Verify the MCP server is running correctly
+4. Press the refresh button in the MCP settings (for Cursor)
+
+### Getting Help
+
+If you continue to experience issues:
+
+1. Check the [GitHub Issues](https://github.com/zilliztech/mcp-server-milvus/issues) for similar problems
+2. Join the [Zilliz Community Discord](https://discord.gg/zilliz) for support
+3. File a new issue with detailed information about your problem

mcp_server_milvus-0.1.1.dev0.dist-info/RECORD

@@ -0,0 +1,8 @@
+mcp_server_milvus/__init__.py,sha256=QuXnVCH_WU32S0g29nGKalTqUnlG5CIKmuKP4N_6taE,185
+mcp_server_milvus/blogpost.md,sha256=GwGlzSnWyotasaYjd_fxQ4dP_n9pMSitvVikNTqOmVc,1600
+mcp_server_milvus/example.env,sha256=ILqUAROPfUqmamYuuvlmX17XWoLZmgEx19uL5RQjyv4,42
+mcp_server_milvus/server.py,sha256=_a-BgsNeMETsxN-1ub7lsALt7a2AXyca2EbymWSaDWU,23930
+mcp_server_milvus-0.1.1.dev0.dist-info/METADATA,sha256=6iBwWEIqXCcDOSj2X_-AYpNvxPAHnBARgBGLFaH0pZM,9846
+mcp_server_milvus-0.1.1.dev0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_server_milvus-0.1.1.dev0.dist-info/entry_points.txt,sha256=hgDPpJb9sC54jlIuSX48i0herxeXYQSsf6nh6CuThj0,68
+mcp_server_milvus-0.1.1.dev0.dist-info/RECORD,,

mcp_server_milvus-0.1.1.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mcp_server_milvus-0.1.1.dev0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcp-server-milvus = mcp_server_milvus.server:main