Release new docs to master

Author: Milvus-doc-bot

v2.5.x/assets/attu_after_data_insertion_1.png

@@ -31,7 +31,7 @@ If you are more familiar with PowerShell or Windows Command Prompt, the command
 2. Download the installation script and save it as `standalone.bat`.​
 
     ```powershell
-    C:\>Invoke-WebRequest https://github.com/milvus-io/milvus/blob/master/scripts/standalone_embed.bat -OutFile standalone.bat​
+    C:\>Invoke-WebRequest https://raw.githubusercontent.com/milvus-io/milvus/refs/heads/master/scripts/standalone_embed.bat -OutFile standalone.bat​
 
     ```
 

v2.5.x/assets/attu_after_data_insertion_2.png

@@ -0,0 +1,284 @@
+---
+id: build_RAG_with_milvus_and_deepseek.md
+summary: In this tutorial, we’ll show you how to build a Retrieval-Augmented Generation (RAG) pipeline using Milvus and DeepSeek.
+title: Build RAG with Milvus and DeepSeek
+---
+
+# Build RAG with Milvus and DeepSeek
+
+<a href="https://colab.research.google.com/github/milvus-io/bootcamp/blob/master/bootcamp/tutorials/integration/build_RAG_with_milvus_and_deepseek.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
+<a href="https://github.com/milvus-io/bootcamp/blob/master/bootcamp/tutorials/integration/build_RAG_with_milvus_and_deepseek.ipynb" target="_blank"><img src="https://img.shields.io/badge/View%20on%20GitHub-555555?style=flat&logo=github&logoColor=white" alt="GitHub Repository"/></a>
+
+[DeepSeek](https://www.deepseek.com/) enables developers to build and scale AI applications with high-performance language models. It offers efficient inference, flexible APIs, and advanced Mixture-of-Experts (MoE) architectures for robust reasoning and retrieval tasks.  
+
+In this tutorial, we’ll show you how to build a Retrieval-Augmented Generation (RAG) pipeline using Milvus and DeepSeek.
+
+
+
+## Preparation
+### Dependencies and Environment
+
+
+```python
+! pip install --upgrade pymilvus[model] openai requests tqdm
+```
+
+> If you are using Google Colab, to enable dependencies just installed, you may need to **restart the runtime** (click on the "Runtime" menu at the top of the screen, and select "Restart session" from the dropdown menu).
+
+DeepSeek enables the OpenAI-style API. You can login to its official website and prepare the [api key](https://platform.deepseek.com/api_keys) `DEEPSEEK_API_KEY` as an environment variable.
+
+
+```python
+import os
+
+os.environ["DEEPSEEK_API_KEY"] = "***********"
+```
+
+### Prepare the data
+
+We use the FAQ pages from the [Milvus Documentation 2.4.x](https://github.com/milvus-io/milvus-docs/releases/download/v2.4.6-preview/milvus_docs_2.4.x_en.zip) as the private knowledge in our RAG, which is a good data source for a simple RAG pipeline.
+
+Download the zip file and extract documents to the folder `milvus_docs`.
+
+
+```python
+! wget https://github.com/milvus-io/milvus-docs/releases/download/v2.4.6-preview/milvus_docs_2.4.x_en.zip
+! unzip -q milvus_docs_2.4.x_en.zip -d milvus_docs
+```
+
+We load all markdown files from the folder `milvus_docs/en/faq`. For each document, we just simply use "# " to separate the content in the file, which can roughly separate the content of each main part of the markdown file.
+
+
+```python
+from glob import glob
+
+text_lines = []
+
+for file_path in glob("milvus_docs/en/faq/*.md", recursive=True):
+    with open(file_path, "r") as file:
+        file_text = file.read()
+
+    text_lines += file_text.split("# ")
+```
+
+### Prepare the LLM and Embedding Model
+
+DeepSeek enables the OpenAI-style API, and you can use the same API with minor adjustments to call the LLM.
+
+
+```python
+from openai import OpenAI
+
+deepseek_client = OpenAI(
+    api_key=os.environ["DEEPSEEK_API_KEY"],
+    base_url="https://api.deepseek.com",
+)
+```
+
+Define a embedding model to generate text embeddings using the `milvus_model`. We use the `DefaultEmbeddingFunction` model as an example, which is a pre-trained and lightweight embedding model.
+
+
+```python
+from pymilvus import model as milvus_model
+
+embedding_model = milvus_model.DefaultEmbeddingFunction()
+```
+
+Generate a test embedding and print its dimension and first few elements.
+
+
+```python
+test_embedding = embedding_model.encode_queries(["This is a test"])[0]
+embedding_dim = len(test_embedding)
+print(embedding_dim)
+print(test_embedding[:10])
+```
+
+    768
+    [-0.04836066  0.07163023 -0.01130064 -0.03789345 -0.03320649 -0.01318448
+     -0.03041712 -0.02269499 -0.02317863 -0.00426028]
+
+
+## Load data into Milvus
+
+### Create the Collection
+
+
+```python
+from pymilvus import MilvusClient
+
+milvus_client = MilvusClient(uri="./milvus_demo.db")
+
+collection_name = "my_rag_collection"
+```
+
+> As for the argument of `MilvusClient`:
+> - Setting the `uri` as a local file, e.g.`./milvus.db`, is the most convenient method, as it automatically utilizes [Milvus Lite](https://milvus.io/docs/milvus_lite.md) to store all data in this file.
+> - If you have large scale of data, you can set up a more performant Milvus server on [docker or kubernetes](https://milvus.io/docs/quickstart.md). In this setup, please use the server uri, e.g.`http://localhost:19530`, as your `uri`.
+> - If you want to use [Zilliz Cloud](https://zilliz.com/cloud), the fully managed cloud service for Milvus, adjust the `uri` and `token`, which correspond to the [Public Endpoint and Api key](https://docs.zilliz.com/docs/on-zilliz-cloud-console#free-cluster-details) in Zilliz Cloud.
+
+Check if the collection already exists and drop it if it does.
+
+
+```python
+if milvus_client.has_collection(collection_name):
+    milvus_client.drop_collection(collection_name)
+```
+
+Create a new collection with specified parameters. 
+
+If we don't specify any field information, Milvus will automatically create a default `id` field for primary key, and a `vector` field to store the vector data. A reserved JSON field is used to store non-schema-defined fields and their values.
+
+
+```python
+milvus_client.create_collection(
+    collection_name=collection_name,
+    dimension=embedding_dim,
+    metric_type="IP",  # Inner product distance
+    consistency_level="Strong",  # Strong consistency level
+)
+```
+
+### Insert data
+Iterate through the text lines, create embeddings, and then insert the data into Milvus.
+
+Here is a new field `text`, which is a non-defined field in the collection schema. It will be automatically added to the reserved JSON dynamic field, which can be treated as a normal field at a high level.
+
+
+```python
+from tqdm import tqdm
+
+data = []
+
+doc_embeddings = embedding_model.encode_documents(text_lines)
+
+for i, line in enumerate(tqdm(text_lines, desc="Creating embeddings")):
+    data.append({"id": i, "vector": doc_embeddings[i], "text": line})
+
+milvus_client.insert(collection_name=collection_name, data=data)
+```
+
+    Creating embeddings:   0%|          | 0/72 [00:00<?, ?it/s]huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...
+    To disable this warning, you can either:
+    	- Avoid using `tokenizers` before the fork if possible
+    	- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)
+    Creating embeddings: 100%|██████████| 72/72 [00:00<00:00, 246522.36it/s]
+
+
+
+
+
+    {'insert_count': 72, 'ids': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71], 'cost': 0}
+
+
+
+## Build RAG
+
+### Retrieve data for a query
+
+Let's specify a frequent question about Milvus.
+
+
+```python
+question = "How is data stored in milvus?"
+```
+
+Search for the question in the collection and retrieve the semantic top-3 matches.
+
+
+```python
+search_res = milvus_client.search(
+    collection_name=collection_name,
+    data=embedding_model.encode_queries(
+        [question]
+    ),  # Convert the question to an embedding vector
+    limit=3,  # Return top 3 results
+    search_params={"metric_type": "IP", "params": {}},  # Inner product distance
+    output_fields=["text"],  # Return the text field
+)
+```
+
+Let's take a look at the search results of the query
+
+
+
+```python
+import json
+
+retrieved_lines_with_distances = [
+    (res["entity"]["text"], res["distance"]) for res in search_res[0]
+]
+print(json.dumps(retrieved_lines_with_distances, indent=4))
+```
+
+    [
+        [
+            " Where does Milvus store data?\n\nMilvus deals with two types of data, inserted data and metadata. \n\nInserted data, including vector data, scalar data, and collection-specific schema, are stored in persistent storage as incremental log. Milvus supports multiple object storage backends, including [MinIO](https://min.io/), [AWS S3](https://aws.amazon.com/s3/?nc1=h_ls), [Google Cloud Storage](https://cloud.google.com/storage?hl=en#object-storage-for-companies-of-all-sizes) (GCS), [Azure Blob Storage](https://azure.microsoft.com/en-us/products/storage/blobs), [Alibaba Cloud OSS](https://www.alibabacloud.com/product/object-storage-service), and [Tencent Cloud Object Storage](https://www.tencentcloud.com/products/cos) (COS).\n\nMetadata are generated within Milvus. Each Milvus module has its own metadata that are stored in etcd.\n\n###",
+            0.6572665572166443
+        ],
+        [
+            "How does Milvus flush data?\n\nMilvus returns success when inserted data are loaded to the message queue. However, the data are not yet flushed to the disk. Then Milvus' data node writes the data in the message queue to persistent storage as incremental logs. If `flush()` is called, the data node is forced to write all data in the message queue to persistent storage immediately.\n\n###",
+            0.6312146186828613
+        ],
+        [
+            "How does Milvus handle vector data types and precision?\n\nMilvus supports Binary, Float32, Float16, and BFloat16 vector types.\n\n- Binary vectors: Store binary data as sequences of 0s and 1s, used in image processing and information retrieval.\n- Float32 vectors: Default storage with a precision of about 7 decimal digits. Even Float64 values are stored with Float32 precision, leading to potential precision loss upon retrieval.\n- Float16 and BFloat16 vectors: Offer reduced precision and memory usage. Float16 is suitable for applications with limited bandwidth and storage, while BFloat16 balances range and efficiency, commonly used in deep learning to reduce computational requirements without significantly impacting accuracy.\n\n###",
+            0.6115777492523193
+        ]
+    ]
+
+
+### Use LLM to get a RAG response
+
+Convert the retrieved documents into a string format.
+
+
+```python
+context = "\n".join(
+    [line_with_distance[0] for line_with_distance in retrieved_lines_with_distances]
+)
+```
+
+Define system and user prompts for the Lanage Model. This prompt is assembled with the retrieved documents from Milvus.
+
+
+```python
+SYSTEM_PROMPT = """
+Human: You are an AI assistant. You are able to find answers to the questions from the contextual passage snippets provided.
+"""
+USER_PROMPT = f"""
+Use the following pieces of information enclosed in <context> tags to provide an answer to the question enclosed in <question> tags.
+<context>
+{context}
+</context>
+<question>
+{question}
+</question>
+"""
+```
+
+Use the `deepseek-chat` model provided by DeepSeek to generate a response based on the prompts.
+
+
+```python
+response = deepseek_client.chat.completions.create(
+    model="deepseek-chat",
+    messages=[
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": USER_PROMPT},
+    ],
+)
+print(response.choices[0].message.content)
+```
+
+    In Milvus, data is stored in two main categories: inserted data and metadata.
+    
+    1. **Inserted Data**: This includes vector data, scalar data, and collection-specific schema. The inserted data is stored in persistent storage as incremental logs. Milvus supports various object storage backends for this purpose, such as MinIO, AWS S3, Google Cloud Storage (GCS), Azure Blob Storage, Alibaba Cloud OSS, and Tencent Cloud Object Storage (COS).
+    
+    2. **Metadata**: Metadata is generated within Milvus and is specific to each Milvus module. This metadata is stored in etcd, a distributed key-value store.
+    
+    Additionally, when data is inserted, it is first loaded into a message queue, and Milvus returns success at this stage. The data is then written to persistent storage as incremental logs by the data node. If the `flush()` function is called, the data node is forced to write all data in the message queue to persistent storage immediately.
+
+
+Great! We have successfully built a RAG pipeline with Milvus and DeepSeek.
+
+

v2.5.x/assets/attu_expanded_searched_graph.png

@@ -1,7 +1,7 @@
 ---
 id: integrate_with_camel.md
-summary: This guide demonstrates how to use an open-source embedding model and large-language model on BentoCloud with Milvus vector database to build a Retrieval Augmented Generation (RAG) application. 
-title: Retrieval-Augmented Generation (RAG) with Milvus and BentoML
+summary: This guide demonstrates how to build a Retrieval-Augmented Generation (RAG) system using CAMEL and Milvus.
+title: Retrieval-Augmented Generation (RAG) with Milvus and Camel
 ---
 
 # Retrieval-Augmented Generation (RAG) with Milvus and Camel

v2.5.x/assets/attu_login_page.png

@@ -1,16 +1,20 @@
 ---
 id: integrate_with_langfuse.md
 summary: This is a simple cookbook that demonstrates how to use the LlamaIndex Langfuse integration. It uses Milvus Lite to store the documents and Query.
-title: Cookbook LlamaIndex & Milvus Integration
+title: Using Langfuse to Evaluate RAG Quality
 ---
 
-# Cookbook - LlamaIndex & Milvus Integration
+# Using Langfuse to Trace Queries in RAG
 
 <a target="_blank" href="https://colab.research.google.com/github/langfuse/langfuse-docs/blob/main/cookbook/integration_llama-index_milvus-lite.ipynb">
   <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
 </a>
 
-This is a simple cookbook that demonstrates how to use the [LlamaIndex Langfuse integration](https://langfuse.com/docs/integrations/llama-index/get-started). It uses Milvus Lite to store the documents and Query. 
+This is a simple cookbook that demonstrates how to use Langfuse to trace your queries in RAG. The RAG pipeline is implemented with LlamaIndex and Milvus Lite to store and retrieve the documents. 
+
+In this quickstart, we’ll show you how to set up a LlamaIndex application using Milvus Lite as the vector store. We’ll also show you how to use the Langfuse LlamaIndex integration to trace your application.
+
+[Langfuse](https://github.com/langfuse/langfuse) is an open-source LLM engineering platform that helps teams collaboratively debug, analyze, and iterate on their LLM applications. All platform features are natively integrated to accelerate the development workflow.
 
 [Milvus Lite](https://github.com/milvus-io/milvus-lite/) is the lightweight version of Milvus, an open-source vector database that powers AI applications with vector embeddings and similarity search.
 

v2.5.x/assets/attu_searched_graph.png

@@ -59,3 +59,4 @@ This page provides a list of tutorials for you to interact with Milvus and third
 | [Build RAG with Milvus and Gemini](build_RAG_with_milvus_and_gemini.md) | LLMs | Milvus, Gemini |
 | [Build RAG with Milvus and Ollama](build_RAG_with_milvus_and_ollama.md) | LLMs | Milvus, Ollama |
 | [Getting Started with Dynamiq and Milvus](milvus_rag_with_dynamiq.md) | Orchestration | Milvus, Dynamiq |
+| [Build RAG with Milvus and DeepSeek](build_RAG_with_milvus_and_deepseek.md) | LLMs | Milvus, DeepSeek |

v2.5.x/assets/attu_searched_table.png

@@ -1737,6 +1737,12 @@
             "id": "build_RAG_with_milvus_and_ollama.md",
             "order": 7,
             "children": []
+          },
+          {
+            "label": "DeepSeek",
+            "id": "build_RAG_with_milvus_and_deepseek.md",
+            "order": 8,
+            "children": []
           }
         ]
       }, 
@@ -2001,7 +2007,7 @@
         "id": "tutorials-overview.md",
         "order": 0,
         "children": []
-      },
+      },           
       {
         "label": "Build RAG with Milvus",
         "id": "build-rag-with-milvus.md",
@@ -2013,7 +2019,7 @@
         "id": "how_to_enhance_your_rag.md",
         "order": 2,
         "children": []        
-      },
+      }, 
       {
         "label": "Full-Text Search with Milvus",
         "id": "full_text_search_with_milvus.md",
@@ -2031,7 +2037,7 @@
         "id": "image_similarity_search.md",
         "order": 5,
         "children": []
-      },
+      },      
       {
         "label": "Multimodal RAG",
         "id": "multimodal_rag_with_milvus.md",
@@ -2080,6 +2086,18 @@
         "order": 13,
         "children": []
       },
+      {
+        "label": "Quickstart with Attu",
+        "id": "quickstart_with_attu.md",
+        "order": 14,
+        "children": []        
+      },
+      {
+        "label": "Use AsyncMilvusClient with asyncio",
+        "id": "use-async-milvus-client-with-asyncio.md",
+        "order": 15,
+        "children": []            
+      },
       {
         "label": "Explore More",
         "id": "explore-more",