A new and improved Milvus bootcamp offers updated guides and easier to follow code examples. Discover how to create your own similarity search solutions with the world's most advanced vector database.

With the release of Milvus 2.0, the team has revamped the Milvus [bootcamp](https://github.com/milvus-io/bootcamp). The new and improved bootcamp offers updated guides and easier to follow code examples for a variety of use cases and deployments. Additionally, this new version is updated for [Milvus 2.0](https://zilliz.com/blog/milvus2.0-redefining-vector-database), a reimagined version of the world's most advanced vector databse.
 

Jump to:
- [Stress test your system against 1M and 100M dataset benchmarks](#stress-test-your-system-against-1m-and-100m-dataset-benchmarks)
- [Explore and build popular vector similarity search solutions](#explore-and-build-popular-vector-similarity-search-solutions)
- [Quickly deploy a fully built application on any system](#quickly-deploy-a-fully-built-application-on-any-system)
- [Use scenario specific notebooks to easily deploy pre-configured applications](#use-scenario-specific-notebooks-to-easily-deploy-pre-configured-applications)
- [Learn how to deploy Milvus in different environments](#learn-how-to-deploy-milvus-in-different-environments)

 

### Stress test your system against 1M and 100M dataset benchmarks 
The [benchmark directory](https://github.com/milvus-io/bootcamp/tree/master/benchmark_test) contains 1 million and 100 million vector benchmark tests that indicate how your system will react to differently sized datasets.

 

### Explore and build popular vector similarity search solutions

The [solution directory](https://github.com/milvus-io/bootcamp/tree/master/solutions) includes the most popular vector similarity search use cases. Each use case contains a notebook solution and a docker deployable solution. Use cases include:

- [Image similarity search](https://github.com/milvus-io/bootcamp/tree/master/solutions/reverse_image_search)
- [Video similarity search](https://github.com/milvus-io/bootcamp/tree/master/solutions/video_similarity_search)
- [Audio similarity search](https://github.com/milvus-io/bootcamp/tree/master/solutions/audio_similarity_search)
- [Recommendation system](https://github.com/milvus-io/bootcamp/tree/master/solutions/recommendation_system)
- [Molecular search](https://github.com/milvus-io/bootcamp/tree/master/solutions/molecular_similarity_search)
- [Question answering system](https://github.com/milvus-io/bootcamp/tree/master/solutions/question_answering_system)

 

### Quickly deploy a fully built application on any system

The quick deploy solutions are dockerized solutions that allow users to deploy fully built applications on any system. These solutions are ideal for brief demos, but require additional work to customize and understand compared to notebooks.

 

### Use scenario specific notebooks to easily deploy pre-configured applications

The notebooks contain a simple example of deploying Milvus to solve the problem in a given use case. Each of the examples are able to be run from start to finish without the need to manage files or configurations. Each notebook is also easy to follow and modifiable, making them ideal base files for other projects.

 

### Image similarity search notebook example
Image similarity search is one of the core ideas behind many different technologies, including autonomous cars recognizing objects. This example explains how to easily build computer vision programs with Milvus.


This [notebook](https://github.com/milvus-io/bootcamp/blob/master/solutions/reverse_image_search/reverse_image_search.ipynb) revolves around three things:
- Milvus server 
- Redis server (for metadata storage)
- Pretrained Resnet-18 model. 


#### Step 1: Download required packages
Begin by downloading all the required packages for this project. This notebook includes a table listing the packages to use.

```
pip install -r requirements.txt
```

#### Step 2: Server startup
After the packages are installed, start the servers and ensure both are running properly. Be sure to follow the correct instructions for starting the [Milvus](https://milvus.io/docs/v2.0.0/install_standalone-docker.md) and [Redis](https://hub.docker.com/_/redis) servers.

#### Step 3: Download project data
By default, this notebook pulls a snippet of the VOCImage data for use as an example, but any directory with images should work as long as it follows the file structure that can be seen at the top of the notebook.

```
! gdown "https://drive.google.com/u/1/uc?id=1jdudBiUu41kL-U5lhH3ari_WBRXyedWo&export=download"
! tar -xf 'VOCdevkit.zip'
! rm 'VOCdevkit.zip'
```

#### Step 4: Connect to the servers
In this example, the servers are running on the default ports on the localhost.

```
connections.connect(host="127.0.0.1", port=19537)
red = redis.Redis(host = '127.0.0.1', port=6379, db=0)
```

#### Step 5: Create a collection
After starting the servers, create a collection in Milvus for storing all the vectors. In this example, the dimension size is set to 512, the size of the resnet-18 output, and the similarity metric is set to the Euclidean distance (L2). Milvus supports a variety of different [similarity metrics](https://milvus.io/docs/metric.md#floating).

```
collection_name = "image_similarity_search"
dim = 512
default_fields = [
 schema.FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=True),
 schema.FieldSchema(name="vector", dtype=DataType.FLOAT_VECTOR, dim=dim)
]
default_schema = schema.CollectionSchema(fields=default_fields, description="Image test collection")
collection = Collection(name=collection_name, schema=default_schema)
```

#### Step 6: Build an index for the collection
Once the collection is made, build an index for it. In this case, the IVF_SQ8 index is used. This index requires the 'nlist' parameter, which tells Milvus how many clusters to make within each datafile (segment). Different [indices](https://milvus.io/docs/index.md#CPU) require different parameters.

```
default_index = {"index_type": "IVF_SQ8", "params": {"nlist": 2048}, "metric_type": "L2"}
collection.create_index(field_name="vector", index_params=default_index)
collection.load()
```
#### Step 7: Set up model and data loader
After the IVF_SQ8 index is built, set up the neural network and data loader. The pretrained pytorch resnet-18 used in this example is sans its last layer, which compresses vectors for classification and may lose valuable information.

```
model = torch.hub.load('pytorch/vision:v0.9.0', 'resnet18', pretrained=True)
encoder = torch.nn.Sequential(*(list(model.children())[:-1]))
```

The dataset and data loader needs to be modified so that they are able to preprocess and batch the images while also providing the file paths of the images. This can be done with a slightly modified torchvision dataloader. For preprocessing, the images need to be cropped and normalized due to the resnet-18 model being trained on a specific size and value range. 

```
dataset = ImageFolderWithPaths(data_dir, transform=transforms.Compose([
 transforms.Resize(256),
 transforms.CenterCrop(224),
 transforms.ToTensor(),
 transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])]))

dataloader = torch.utils.data.DataLoader(dataset, num_workers=0, batch_si
```

#### Step 8: Insert vectors into the collection
With the collection setup, the images can be processed and loaded into the created collection. First the images are pulled by the dataloader and run through the resnet-18 model. The resulting vector embeddings are then inserted into Milvus, which returns a unique ID for each vector. The vector IDs and image file paths are then inserted as key-value pairs into the Redis server.

```
steps = len(dataloader)
step = 0
for inputs, labels, paths in dataloader:
 with torch.no_grad():
 output = encoder(inputs).squeeze()
 output = output.numpy()

 mr = collection.insert([output.tolist()])
 ids = mr.primary_keys
 for x in range(len(ids)):
 red.set(str(ids[x]), paths[x])
 if step%5 == 0:
 print("Insert Step: " + str(step) + "/" + str(steps))
 step += 1
```

#### Step 9: Conduct a vector similarity search
Once all of the data is inserted into Milvus and Redis, the actual vector similarity search can be performed. For this example, three randomly selected images are pulled out of the Redis server for a vector similarity search. 

```
random_ids = [int(red.randomkey()) for x in range(3)]
search_images = [x.decode("utf-8") for x in red.mget(random_ids)]
```
These images first go through the same preprocessing that is found in Step 7 and are then pushed through the resnet-18 model. 

```
transform_ops = transforms.Compose([
 transforms.Resize(256),
 transforms.CenterCrop(224),
 transforms.ToTensor(),
 transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])
 
embeddings = [transform_ops(Image.open(x)) for x in search_images]
embeddings = torch.stack(embeddings, dim=0)
 
with torch.no_grad():
 embeddings = encoder(embeddings).squeeze().numpy()
```
Then the resulting vector embeddings are used to perform a search. First, set the search parameters, including the name of the collection to search, nprobe (the number of the clusters to search), and top_k (the number of returned vectors). In this example, the search should be very quick. 

```
search_params = {"metric_type": "L2", "params": {"nprobe": 32}}
start = time.time()
results = collection.search(embeddings, "vector", param=search_params, limit=3, expr=None)
end = time.time() - start
```

#### Step 10: Image search results 
The vector IDs returned from the queries are used to find the corresponding images. Matplotlib is then used to display the image search results.
 

![pic1.png](https://assets.zilliz.com/pic1_c8652c7fae.png)
![pic2.png](https://assets.zilliz.com/pic2_355b054161.png)
![pic3.png](https://assets.zilliz.com/pic3_01780c6aac.png)

 

### Learn how to deploy Milvus in different enviroments
The [deployments section](https://github.com/milvus-io/bootcamp/tree/master/deployments) of the new bootcamp contains all the information for using Milvus in different environments and setups. It includes deploying Mishards, using Kubernetes with Milvus, load balancing, and more. Each environment has a detailed step by step guide explaining how to get Milvus working in it.

 

### Don't be a stranger
- Read our our [blog](https://zilliz.com/blog).
- Interact with our open-source community on [Slack](https://join.slack.com/t/milvusio/shared_invite/zt-e0u4qu3k-bI2GDNys3ZqX1YCJ9OM~GQ).
- Use or contribute to Milvus, the world’s most popular vector database, on [Github](http://page/).

thumbnail_cover.png

cover.png

Build, test, and customize vector similarity search solutions with Milvus, an open-source vector database.

Quickly Test and Deploy Vector Search Solutions with the Milvus 2.0 Bootcamp

Milvus v1.1.0 is available now. Discover new features, improvements, and bug fixes made to the world' most popular vector database.

[Milvus](https://github.com/milvus-io) is an ongoing open-source software (OSS) project focused on building the world's fastest and most reliable vector database. New features inside Milvus v1.1.0 are the first of many updates to come, thanks to long-term support from the open-source community and sponsorship from Zilliz. This blog article covers the new features, improvements, and bug fixes included with Milvus v1.1.0.

**Jump to:**

- [New features](#new-features)
- [Improvements](#improvements)
- [Bug fixes](#bug-fixes)

 

## New features

Like any OSS project, Milvus is a perpetual work in progress. We strive to listen to our users and the open-source community to prioritize the features that matter most. The latest update, Milvus v1.1.0, offers the following new features:

### Specify partitions with `get_entity_by_id()` method calls

To further accelerate vector similarity search, Milvus 1.1.0 now supports retrieving vectors from a specified partition. Generally, Milvus supports querying vectors through specified vector IDs. In Milvus 1.0, calling the method `get_entity_by_id()` searches the entire collection, which can be time consuming for large datasets. As we can see from the code below, `GetVectorsByIdHelper` uses a `FileHolder` structure to loop through and find a specific vector. 

```
std::vector<meta::CollectionSchema> collection_array; 
 auto status = meta_ptr_->ShowPartitions(collection.collection_id_, collection_array); 
 
 collection_array.push_back(collection); 
 status = meta_ptr_->FilesByTypeEx(collection_array, file_types, files_holder); 
 if (!status.ok()) { 
 std::string err_msg = "Failed to get files for GetVectorByID: " + status.message(); 
 LOG_ENGINE_ERROR_ << err_msg; 
 return status; 
 } 
 
 if (files_holder.HoldFiles().empty()) { 
 LOG_ENGINE_DEBUG_ << "No files to get vector by id from"; 
 return Status(DB_NOT_FOUND, "Collection is empty"); 
 } 
 
 cache::CpuCacheMgr::GetInstance()->PrintInfo(); 
 status = GetVectorsByIdHelper(id_array, vectors, files_holder); 
DBImpl::GetVectorsByIdHelper(const IDNumbers& id_array, std::vector<engine::VectorsData>& vectors, 
 meta::FilesHolder& files_holder) { 
 // attention: this is a copy, not a reference, since the files_holder.UnMarkFile will change the array internal 
 milvus::engine::meta::SegmentsSchema files = files_holder.HoldFiles(); 
 LOG_ENGINE_DEBUG_ << "Getting vector by id in " << files.size() << " files, id count = " << id_array.size(); 
 
 // sometimes not all of id_array can be found, we need to return empty vector for id not found 
 // for example: 
 // id_array = [1, -1, 2, -1, 3] 
 // vectors should return [valid_vector, empty_vector, valid_vector, empty_vector, valid_vector] 
 // the ID2RAW is to ensure returned vector sequence is consist with id_array 
 using ID2VECTOR = std::map<int64_t, VectorsData>; 
 ID2VECTOR map_id2vector; 
 
 vectors.clear(); 
 
 IDNumbers temp_ids = id_array; 
 for (auto& file : files) { 
```

However, this structure is not filtered by any partitions in `FilesByTypeEx()`. In Milvus v1.1.0, it is possible for the system to pass partition names to the `GetVectorsIdHelper` loop so that the `FileHolder` only contains segments from specified partitions. Put differently, if you know exactly which partition the vector for a search belongs to, you can specify the partition name in a `get_entity_by_id()` method call to accelerate the search process.

We not only made modifications to code controlling system queries at the Milvus server level, but also updated all our SDKs(Python, Go, C++, Java, and RESTful) by adding a parameter for specifying partition names. For example, in pymilvus, the definition of `get_entity_by_id` `def get_entity_by_id(self, collection_name, ids, timeout=None)` is changed to `def get_entity_by_id(self, collection_name, partition_tags=None, ids, timeout=None)`.

 

### Specify partitions with `delete_entity_by_id()` method calls

To make vector management more efficient, Milvus v1.1.0 now supports specifying partition names when deleting a vector in a collection. In Milvus 1.0, vectors in a collection can only be deleted by ID. When calling the delete method, Milvus will scan all vectors in the collection. However, it is far more efficient to scan only relevant partitions when working with massive million, billion, or even trillion vector datasets. Similar to the new feature for specifying partitions with `get_entity_by_id()` method calls, modifications were made to the Milvus code using the same logic.

 

### New method `release_collection()`

To free up memory Milvus used to load collections at runtime, a new method `release_collection()` has been added in Milvus v1.1.0 to manually unload specific collections from cache.

 

## Improvements

Although new features are usually all the rage, it's also important to improve what we already have. What follows are upgrades and other general improvements over Milvus v1.0.

 

### Improved performance of `get_entity_by_id()` method call

The chart below is a comparison of vector search performance between Milvus v1.0 and Milvus v1.1.0:

> CPU: Intel(R) Core(TM) i7-8550U CPU @ 1.80GHz * 8 
> Segment file size = 1024 MB 
> Row count = 1,000,000 
> Dim = 128 

| Query ID Num | v 1.0.0 | v1.1.0 |
| :-----------: | :-----------: | :-----------: |
| 10 | 9 ms | 2 ms |
| 100 | 149 ms | 19 ms |

 

### Hnswlib upgraded to v0.5.0

Milvus adopts multiple widely used index libraries, including Faiss, NMSLIB, Hnswlib, and Annoy to simplify the process of choosing the right index type for a given scenario.

Hnswlib has been upgraded from v0.3.0 to v0.5.0 in Milvus 1.1.0 due to a bug detected in the earlier version. Additionally, upgrading Hnswlib improves `addPoint()` performance in index building.

A Zilliz developer created a pull request (PR) to improve Hnswlib performance while building indexes in Milvus. See [PR #298](https://github.com/nmslib/hnswlib/pull/298) for details.

The chart below is a comparison of `addPoint()` performance between Hnswlib 0.5.0 and the proposed PR:

> CPU: Intel(R) Core(TM) i7-8550U CPU @ 1.80GHz * 8 
> Dataset: sift_1M (row count = 1000000, dim = 128, space = L2)

| | 0.5.0 | PR-298 |
| :-----------: | :-----------: | :-----------: |
| M = 16, ef_construction = 100 | 274406 ms | 265631 ms |
| M = 16, ef_construction = 200 | 522411 ms | 499639 ms |

 

### Improved IVF index training performance

Creating an index includes training, inserting and writing data to disk. Milvus 1.1.0 improves the training component of index building. The chart below is a comparison of IVF index training performance between Milvus 1.0 and Milvus 1.1.0:

> CPU: Intel(R) Core(TM) i7-8550U CPU @ 1.80GHz * 8 
> Dataset: sift_1m (row_count = 1000000, dim = 128, metric_type = L2)

| | v1.0.0 (ms) | v1.1.0 (ms) |
| :-----------: | :-----------: | :-----------: |
| ivf_flat (nlist = 2048) | 90079 | 81544 |
| ivf_pq (nlist = 2048, m=16) | 103535 | 97115 |
| ivf_pq (nlist = 2048, m=32) | 108638 | 104558 |
| ivf_flat (nlist = 4096) | 340643 | 310685 |
| ivf_pq (nlist = 4096, m=16) | 351982 | 323758 |
| ivf_pq (nlist = 4096, m=32) | 357359 | 330887 |


 

## Bug fixes

We also fixed some bugs to make Milvus more stable and efficient when managing vector datasets. See [Fixed Issues](https://milvus.io/docs/v1.1.0/release_notes.md#Fixed-issues) for more details.

large_v1.1 cover.jpeg

medium_v1.1 cover.jpeg

small_v1.1 cover.jpeg

thumbnail_v1.1 cover.jpeg

v1.1 cover.jpeg

Milvus v1.1.0 has arrived! New features, improvements, and bug fixes are available now.

Inside Milvus 1.1.0

We are proud to announce Milvus v1.0, a stable, long-term support version of the world’s most popular open-source vector database. Discover what Milvus v1.0 has to offer, and plans for the platform’s future.

Zilliz is proud to announce the release of Milvus v1.0. After months of extensive testing Milvus v1.0, which is based on a stable version of Milvus v0.10.6, is available for use.

Milvus v1.0 offers the following key features:

- Support for mainstream similarity metrics, including Euclidean distance, inner product, Hamming distance, Jaccard coefficient, and more.
- Integration with, and improvements to, SOTA ANNs algorithms, including Faiss, Hnswlib, Annoy, NSG, and more. 
- Scale-out capability through the Mishards sharding proxy.
- Support for processors commonly used in AI scenarios, including X86, Nvidia GPU, Xilinx FPGA, and more.

See the [Release Notes](https://www.milvus.io/docs/v1.0.0/release_notes.md) for additional Milvus v1.0 features. 

Milvus is an ongoing open-source software (OSS) project. Its first major release has the following implications for users:

- Milvus v1.0 will receive long-term support (3+ years).
- The most stable Milvus release to date is well structured and ready for integration with existing AI ecosystems.

### The first version of Milvus with long-term support

Thanks in part to sponsorship from Zilliz, the Milvus community will provide bug fix support for Milvus v1.0 until December 31st, 2024. New features will be available only in releases following v1.0.

See [The Milvus release guideline](https://milvus.io/docs/v1.0.0/milvus_release_guideline.md) for information about release cadences and more.

### Toolchain enhancements and seamless AI ecosystem integration

Beginning with v1.0, Milvus' toolchain will be a primary development focus. We plan to create the necessary tooling and utilities to meet the needs of the Milvus user community. 

Stability makes integrating Milvus with AI ecosystems a breeze. We are seeking further collaboration between the Milvus community and other AI-focused OSS communities. We encourage contributions to the new AI ASICs (application-specific integrated circuits) in Milvus. 

### The future of Milvus

We believe Milvus has a bright future thanks to the following factors:

- Regular contributions from developers in the Milvus community.
- Support for integration with any cloud-native environment.

We have drafted [community charters](https://milvus.io/docs/v1.0.0/milvus_community_charters.md) to help guide, nurture, and advance the Milvus community as our technology and user base grows. The charters include several technical decisions made to attract more participants to the community.

- Golang will now be used to develop the Milvus engine however, the ANNS algorithm component will still be developed in C++.
- The forthcoming distributed version of Milvus will use existing cloud components as much as possible.

We are thrilled to partner with the open-source software community to build the next-generation cloud data fabric made for AI. Let's get to work!

### Don’t be a stranger

- Find or contribute to Milvus on [GitHub](https://github.com/milvus-io/milvus/)
- Interact with the community via [Slack](https://join.slack.com/t/milvusio/shared_invite/zt-e0u4qu3k-bI2GDNys3ZqX1YCJ9OM~GQ).
- Connect with us on [Twitter](https://twitter.com/milvusio).

large_Milvus.jpeg

medium_Milvus.jpeg

small_Milvus.jpeg

thumbnail_Milvus.jpeg

Milvus.jpeg

Milvus v1.0 is available now. This stable, long-term support version powers image/video search, chatbots, and many more AI applications.

Milvus 1.0: The World's Most Popular Open-Source Vector Database Just Got Better

Recommending engaging content at lightening speed inside Xiaomi’s mobile news aggregator. 

Xiaomi is a global electronics company that manufactures and invests in smartphones, mobile applications, laptops, home appliances, laptops, and many other products. The company ships its smartphones with a home brewed web browser that has a news aggregator embedded within it. To consistently make content recommendations that appeal to individual users Xiaomi leveraged artificial intelligence (AI).

Milvus, an open-source vector database built by Zilliz, is used to power the core recommendation engine inside Xiaomi's smart news aggregator.


small_xiaomi.png

thumbnail_xiaomi.png

xiaomi.png

large_05.jpg

medium_05.jpg

small_05.jpg

thumbnail_05.jpg

05.jpg

Xiaomi’s Smart News Aggregator

large_beike.png

medium_beike.png

small_beike.png

thumbnail_beike.png

beike.png

Extracting highlights from massive video data for individual marathon runners or participants in other events.

iYUNDONG builds artificial intelligence (AI) tools that analyze media captured during sporting events to automatically extract key highlights. For example, by uploading a single photo, images of individual marathon runners can be automatically retrieved from a massive dataset that includes photos and videos from the event. 

iYUNDONG leverages Milvus, an open-source vector database built by Zilliz, to power its core image retrieval system.

thumbnail_iyundong.png

iyundong.png

large_iyundong.jpg

medium_iyundong.jpg

small_iyundong.jpg

thumbnail_iyundong.jpg

iyundong.jpg

iYUNDONG‘s AI Automatically Extracts Sporting Event Highlights

large_iyundong.png

medium_iyundong.png

small_iyundong.png

Helping people create relevant, high-quality documents at the click of a button inside WPS Office's Writer.

WPS Office is a productivity tool developed by Kingsoft with over 300M monthly active users worldwide. The company’s artificial intelligence (AI) department built a smart writing assistant from scratch using semantic matching algorithms such as intent recognition and text clustering. The tool helps users quickly create outlines, individual paragraphs, and entire documents by simply inputting a title and selecting up to five keywords.

Kingsoft’s writing assistant uses Milvus, an open-source vector database built by Zilliz, to power its core vector processing module.



small_wps.png

thumbnail_wps.png

wps.png

large_wps-blog-cover.png

medium_wps-blog-cover.png

small_wps-blog-cover.png

thumbnail_wps-blog-cover.png

wps-blog-cover.png

Kingsoft’s AI-Powered Writing Assistant

Reducing vector retrieval time from days to hours and minimizing false positive results in short text classification. 



Sohu is a Nasdaq-listed company that offers advertising, search engine, online multiplayer gaming, and many other services. The company built the Sohu News App to provide its users with personalized content. To improve the click-through rate (CTR) and relevance of the app’s recommendations, Sohu leveraged semantic vector similarity search.

Sohu used Milvus, an open-source vector database built by Zilliz, to power the core semantic similarity search engine inside its intelligent news aggregator.



sohu.png

large_sohu-story-cover.jpg

medium_sohu-story-cover.jpg

small_sohu-story-cover.jpg

thumbnail_sohu-story-cover.jpg

sohu-story-cover.jpg

Sohu’s AI News Aggregator

large_sohu-user-image.jpg

medium_sohu-user-image.jpg

small_sohu-user-image.jpg

thumbnail_sohu-user-image.jpg

sohu-user-image.jpg

Recommending outfits and enabling image search in Mozat's Stylepedia lifestyle app.

[Mozat](http://www.mozat.com/home) is a Singaporean start-up focused on building innovative social media, communication, and lifestyle applications. [Stylepedia](https://stylepedia.com/) is a digital closet and outfit planning app that helps people passionate about fashion discover and discuss couture. Stylepedia users can create their own digital closets, receive personalized styling suggestions, and interact with other users to share fashion tips and trends.

Milvus, an open-source vector database, is used to power the image similarity search system that Stylepedia relies on to realize its image search and outfit recommender functionalities.

thumbnail_icon-mozat.jpg

icon-mozat.jpg

large_mozat-story-cover.jpg

medium_mozat-story-cover.jpg

small_mozat-story-cover.jpg

thumbnail_mozat-story-cover.jpg

mozat-story-cover.jpg

Mozat's wardrobe app powered by an image search system built with Milvus

large_mozat-user image.jpg

medium_mozat-user image.jpg

small_mozat-user image.jpg

thumbnail_mozat-user image.jpg

mozat-user image.jpg

Matching what people see in everyday life with artworks from the Cleveland Museum of Art's extensive collection.

Determined to adapt amid the limitations placed on in-person experiences by the coronavirus pandemic, the Cleveland Museum of art sought new, creative, and easy ways for people to engage with art. In this vein, CMA developed a reverse image search tool called "Artlens AI: Share Your View" that is capable of recognizing shapes, patterns, objects, and even architecture in user uploaded photos. After a user submits a photo, ArtLens AI returns the closest match from the CMA's vast art collection. The museum's hope is that by placing artwork next to contemporary views people will be given new perspectives and opportunities for critical thinking.

Milvus, an open-source vector database built by Zilliz, was used to power Artlens AI's core vector management module.

thumbnail_CMA logo.png

CMA logo.png

large_Blog_ArtLens AI_ 1.jpeg

medium_Blog_ArtLens AI_ 1.jpeg

small_Blog_ArtLens AI_ 1.jpeg

thumbnail_Blog_ArtLens AI_ 1.jpeg

Blog_ArtLens AI_ 1.jpeg

The Cleveland Museum of Art Uses AI to Connect Daily Life with Art History

large_artlens AI interface.png

medium_artlens AI interface.png

small_artlens AI interface.png

thumbnail_artlens AI interface.png

artlens AI interface.png

Enriching video content recommendations for Opera.

Opera is a Norwegian software company that creates some of the world's most popular web browsers, Opera News, and other services. The company is a pioneer in leveraging artificial intelligence to make digital content recommendations. To ensure users are served a wide variety of videos, and to avoid recommending the same content multiple times, Opera built a smart video reduplication system inside its video content recommendation platform.

Milvus, an open-source vector database built by Zilliz, is used to power Opera’s smart video deduplication system.

thumbnail_Frame 247.jpg

Frame 247.jpg

large_opera-blog-cover.png

medium_opera-blog-cover.png

small_opera-blog-cover.png

thumbnail_opera-blog-cover.png

opera-blog-cover.png

Opera’s Intelligent Video Deduplication System

large_opera-img.png

medium_opera-img.png

small_opera-img.png

thumbnail_opera-img.png

opera-img.png

Mitigating threats to critical data and strengthening cybersecurity with real-time virus detection.

Trend Micro is a global leader in hybrid cloud security, network defense, small business security, and endpoint security. To protect Android devices from viruses, the company built Trend Micro Mobile Security—a mobile app that compares APKs from the Google Play Store to a database of known malware. If an APK with nefarious code is found, the app provides users with detailed information about the virus and its threat level.


Milvus, an open-source vector database built by Zilliz, is used to power Trend Micro Mobile Security’s virus vector comparison module. 



thumbnail_trend icon.png

trend icon.png

large_trend-story-cover.jpg

medium_trend-story-cover.jpg

small_trend-story-cover.jpg

thumbnail_trend-story-cover.jpg

trend-story-cover.jpg

Trend Micro’s Mobile Security App

large_Trend Micro interface.png

medium_Trend Micro interface.png

small_Trend Micro interface.png

thumbnail_Trend Micro interface.png

Trend Micro interface.png

Energizing a personalized recommender service with unstructured data search on Vipshop’s e-commerce platform.

Vipshop is a leading online discount retailer for brands in China. The company offers high quality and popular branded products to consumers throughout China at a significant discount from retail prices. To optimize the shopping experience for their customers, the company built a personalized search recommendation system based on user query keywords and user portraits.
Milvus, an open-source vector database built by Zilliz, is used to power the personalized recommender system on Vipshop’s mobile apps.

large_vipshop-blog.jpg

medium_vipshop-blog.jpg

small_vipshop-blog.jpg

thumbnail_vipshop-blog.jpg

vipshop-blog.jpg

large_vipshop-story-cover.jpg

medium_vipshop-story-cover.jpg

small_vipshop-story-cover.jpg

thumbnail_vipshop-story-cover.jpg

vipshop-story-cover.jpg

Vipshop's Personalized Recommender System

large_vipshop-user image.jpg

medium_vipshop-user image.jpg

small_vipshop-user image.jpg

thumbnail_vipshop-user image.jpg

vipshop-user image.jpg

Making search results more relevant and boosting online product sales on Tokopedia's e-commerce platform.

Tokopedia is a technology company specializing in e-commerce. Its marketplace is the most popular online shopping platform in Indonesia, with 100+ million monthly active users and 9.7+ million merchants. To make search results more relevant and improve user engagement, Tokopedia built a smart search engine capable of pairing low fill rate keywords with high fill rate keywords.

Milvus, an open-source vector database built by Zilliz, is used to index the underlying product database and optimize Tokopedia's AI-enabled shopping experience.

small_tokopedia.jpeg

thumbnail_tokopedia.jpeg

tokopedia.jpeg

large_beike-blog-cover.jpg

medium_beike-blog-cover.jpg

small_beike-blog-cover.jpg

thumbnail_beike-blog-cover.jpg

beike-blog-cover.jpg

Tokopedia’s AI-enabled E-commerce Site Search

Powering semantic search inside LucidWorks Fusion data discovery platform.

Lucidworks is an enterprise search technology company that offers an application development platform, commercial support, and value-add software for open-source Apache Lucene and Apache Solr. The company built Lucidworks Fusion in a modern, containerized, cloud-native architecture that simplifies the process of deploying AI-powered data discovery and search applications. To ensure users find relevant data fast, Lucidworks implemented semantic search using the vector similarity approach.

Milvus, an open-source vector database built by Zilliz, is used to power the core semantic search module inside Lucidworks Fusion.

thumbnail_icon_Lucidworks.jpg

icon_Lucidworks.jpg

large_lucid-blog-cover.jpg

medium_lucid-blog-cover.jpg

small_lucid-blog-cover.jpg

thumbnail_lucid-blog-cover.jpg

lucid-blog-cover.jpg

Lucidworks Fusion Data Discovery Platform

large_lucid-user-image.jpg

medium_lucid-user-image.jpg

small_lucid-user-image.jpg

thumbnail_lucid-user-image.jpg

lucid-user-image.jpg

Powering a unique shopping experience with image search on VOVA’s e-commerce platform.

VOVA is an emerging e-commerce platform that focuses on affordability and offering a positive shopping experience to its users, with listings covering millions of products and support for 20 languages and 35 major currencies. To enhance the shopping experience for its users, the company built image search functionality into its e-commerce platform.

Milvus, an open-source vector database built by Zilliz, is used to power the Search by Image tool on VOVA’s mobile apps.

thumbnail_vova-icon.jpg

vova-icon.jpg

large_vova-blog-cover.jpg

medium_vova-blog-cover.jpg

small_vova-blog-cover.jpg

thumbnail_vova-blog-cover.jpg

vova-blog-cover.jpg

VOVA’s Search by Image Shopping Experience

large_vova-user-image.jpg

medium_vova-user-image.jpg

small_vova-user-image.jpg

thumbnail_vova-user-image.jpg

vova-user-image.jpg

Enabling users to build a reliable, production-ready semantic search pipeline.

Haystack is an end-to-end framework that enables users to build powerful and production-ready pipelines for different search use cases. Using state-of-the-art natural language processing (NLP) models, Haystack users can create neural question answering (QA) or semantic document search applications. This helps create unique search experiences and improve the relevance of QA systems.

Haystack integrates Milvus, an open-source vector database built by Zilliz, to power its core vector processing module.

thumbnail_icon_vova.jpg

icon_deepset.jpg

Deepset.ai’s Semantic Search Framework

Milvus 2.0 is here!

Meet the company behind Milvus.

Milvus 2.0 is here!

Meet the company behind Milvus.

Milvus 2.0 is here!

Milvus:

The world's most advanced open-source vector database

Vector Similarity Search

AI for Everything

Ready for the Cloud

Optimal MLOps

Milvus is trusted by over 1000 organizations worldwide and has applications in almost every industry.

Mitigating threats to critical data and strengthening cybersecurity with real-time virus detection.

Blog

Articles, updates, news and more.

Quickly Test and Deploy Vector Search Solutions with the Milvus 2.0 Bootcamp

Inside Milvus 1.1.0

Milvus 1.0: The World's Most Popular Open-Source Vector Database Just Got Better