Preface

“The big model is very clever, but it doesn’t seem to solve any problem.”

This should be a problem that many users will face when using large models.

For example, if you ask deepseek what customs are there for the upcoming Qingming Festival, AI can give an answer by citing classics; but if you ask it to give a three-day and two-night Qingming travel plan, the answer it gives always seems to be a little off.

The reason is simple: when planning a trip, the big model lacks access to necessary data and tools such as weather, air tickets, railways, navigation, hotels, etc. It is like a top-notch brain, but without external "data" input and strong limbs.

In this context, Agent has become a popular subject in recent years by equipping large models with various external tools and databases.

However, a sufficiently intelligent agent usually requires the addition of a lot of external tools. However, in the traditional agent development process, every time we add a tool, we need to write an additional API for the large model , and the system will become chaotic.

The emergence of MCP (Model Context Protocol) changed this situation.

Last November, Silicon Valley AI unicorn Anthropic officially launched MCP - Model Context Protocol, which allows developers to connect large models to different APIs, databases and file systems with just one write, greatly reducing the difficulty of model configuration.

For this reason, once MCP was launched, it was regarded as the strongest standardized interface protocol, became popular overnight in the global large model circle, and became the standard protocol for calling the new generation of Agent tools.

So, what exactly is MCP and how do we combine it with Milvus?

01 

What is Model Context Protocol (MCP)

MCP is an open protocol that aims to standardize how large models connect to different data sources and tools.

With MCP, LLM is like being equipped with a standard type C charging interface, which can be quickly connected to any tool that supports MCP.

From a technical architecture perspective, MCP uses a client-server architecture, where a host application can connect to multiple (tool) servers:

• MCP host: Programs that want to access data through MCP, such as Claude desktop, integrated development environment (IDE), or AI tools

• MCP client: a protocol client that maintains a one-to-one connection with the server

• MCP Server: A lightweight program that connects to specific functions through a standardized Model Context Protocol

• Local data sources: computer files, databases, and services that the MCP server can securely access

• Remote Services: External systems on the Internet to which the MCP server can connect (e.g., via an API)

02

Why use Milvus with MCP?

Milvus is not only good at managing massive data, but its efficient similarity search and scalable vector storage capabilities make it an ideal choice for AI Agents.

With MCP acting as the "perfect middleman", developers can achieve seamless and standardized access to vector database knowledge for large models without additional engineering investment.

So, what functions can we obtain by accessing Milvus through MCP?

• Complex vector similarity search

• Creating and manipulating indexes

• Schema Analysis: Inspect collection schemas, field types, and index configurations directly through the AI ​​agent interface.

• Real-time Monitoring: Query collection statistics, entity counts, and database health metrics to ensure optimal performance.

• Dynamic operations: Create new collections, insert data, and modify schemas in real time based on changing requirements

• Full-text search: Since Milvus 2.5, all new versions support full-text search

03

How to integrate milvus with large models through MCP?

Milvus MCP server can be used with various LLM applications that support MCP, including but not limited to

• Claude Desktop: Anthropic's desktop application for Claude

• Cursor: AI code editor with Composer support for MCP

• Custom MCP Client: Any application that accesses the MCP Client specification

Next, we will use Claude Desktop and Cursor to demonstrate the deployment.

Step 1: Environmental Preparation

Before using the MCP server, please make sure you have:

1. Python 3.10 or higher;

2. A running Milvus instance (local or remote)

3. UV Tools

Step 2: Configuration Guide

We recommend that milvus MCP server be run directly with uv. Claude Desktop and Cursor in the following examples can be configured in this way.

git clone https://github.com/zilliztech/mcp-server-milvus.git

cd mcp-server-milvus

Next, we can run the server directly:

uv run src/mcp_server_milvus/server.py --milvus-uri http://localhost:19530

Step 3: Integrate with Claude Desktop

Step 1: Install Claude Desktop from https://claude.ai/download

Step 2: Open your Claude Desktop configuration:

macOS:

~/Library/Application Support/Claude/claude_desktop_config.json

step3: Add the following configuration

{"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"]}}}

step4: Restart Claude desktop

Step 4: Integrate with Cursor

Cursor can support MCP tools through the Agent feature in Composer. We can add Milvus MCP server to Cursor in two ways:

Method 1: Use Cursor to set UI

• Step 1: Go to Cursor Settings > Features > MCP

• step2: + Add New MCP Server button

• Step 3 Fill in the configuration: Type selects stdio; name selects milvus; Command is as follows

/PATH/TO/uv --directory /path/to/mcp-server-milvus/src/mcp_server_milvus run server.py --milvus-uri http://127.0.0.1:19530

Method 2: Use project-specific configuration (recommended)

Step 1: Create a . cursor/mcp.json file in the project root directory:

mkdir -p /path/to/your/project/.cursor

step2: Create a mcp.json file with the following content:

{"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"]}}}

Step 3: Restart Cursor or reload the window

After adding the server, we need to click the refresh button in the MCP settings to activate the tool list. In this way, when we query related content, the Composer Agent can automatically use the Milvus tool.

Step 4: Verify the integration effect

To verify that Cursor has been successfully integrated with the Milvus MCP server:

Open Cursor Settings > Features > MCP

Check if "Milvus" appears in the MCP server list

Verify whether the tool is integrated successfully (such as milvus_list_collections, milvus_vector_search, etc.)

04

Case Showcase

Claude Desktop+MCP+milvus effect display

Example 1: Asking a question

First, let’s ask a question

What are the collections I have in my Milvus DB?

Next, Claude will use MCP to retrieve information related to the above questions in Milvus.

I'll check what collections are available in your Milvus database.View result from milvus-list-collections from milvus (local)Here are the collections in your Milvus database:rag_demotestchat_messagestext_collectionimage_collectioncustomized_setupstreaming_rag_demo

Example 2: Searching for documents

First, we give a clear requirement

Find documents in my text_collection that mention "machine learning"

Claude will use Milvus's full-text search feature 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]

Cursor+MCP+milvus effect display

In Cursor's Composer, you can ask:

Create a new collection called 'articles'  in Milvus with  fields  for title ( string ), content ( string ), and a vector field ( 128 dimensions)

The Cursor will use the MCP server to do this:

I'll create a new collection called 'articles'  with the specified fields.
> View  result  from milvus- create -collection from milvus ( local )
Collection 'articles' has been created successfully with the following  schema :- title: string- content : string- vector: float vector[ 128