使用 Milvus 与 Ollama 进行文本向量存储与检索

最新推荐文章于 2025-04-23 12:23:19 发布
最新推荐文章于 2025-04-23 12:23:19 发布
阅读量1.5k 收藏 18
点赞数 24
分类专栏： RAG 文章标签： milvus embedding java AIGC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/fenglingguitar/article/details/145762234
版权

在这篇博客中，我们将展示如何将 Milvus 和 Ollama 结合使用，完成文本的向量化并存储在 Milvus 向量数据库中，同时演示如何进行相似度搜索。Milvus 是一个高效的向量数据库，适用于大规模的相似度搜索任务，而 Ollama 提供了强大的文本嵌入功能，能将文本转换为向量。通过结合这两个工具，我们能够快速实现高效的文本搜索系统。

项目概述

  1. Milvus 用于存储向量数据和执行快速相似度搜索。
  2. Ollama 提供文本嵌入 API，将文本转化为高维向量，作为 Milvus 中存储的向量数据。
  3. 我们将首先在 Milvus 中创建一个集合，并定义存储结构，然后将文本数据和对应的向量插入到该集合中，最后实现向量的相似度查询。

环境准备

  • Milvus 服务器：用于存储向量数据，支持高效的相似度搜索，安装 这里。
  • Ollama 服务器：提供文本到向量的转换 API， 安装 这里。
  • Java 开发环境：我们使用 Java 编写本示例代码，调用 Milvus 的客户端 API 和 Ollama 的 API。

步骤 1：连接到 Milvus 服务器

首先，我们需要连接到 Milvus 服务器。配置连接时，我们需要指定 Milvus 的服务地址和访问凭证。代码如下：

String CLUSTER_ENDPOINT = "http://localhost:19530";
String TOKEN = "root:Milvus";

// Milvus 连接配置
ConnectConfig connectConfig = ConnectConfig.builder()
        .uri(CLUSTER_ENDPOINT)
        .token(TOKEN)
        .build();

MilvusClientV2 client = new MilvusClientV2(connectConfig);

步骤 2：创建集合及其 Schema

在 Milvus 中，我们首先需要创建一个集合，并定义该集合的字段结构（Schema）。我们的集合将包含以下三个字段：

  1. id：主键字段，类型为 Int64。
  2. text：文本字段，类型为 VarChar，用于存储原始文本。
  3. vector：向量字段，类型为 FloatVector，存储文本的向量表示。
CreateCollectionReq.CollectionSchema schema = client.createSchema();

schema.addField(AddFieldReq.builder()
        .fieldName("id")
        .dataType(DataType.Int64)
        .isPrimaryKey(true)
        .autoID(false)
        .build());

schema.addField(AddFieldReq.builder()
        .fieldName("text")
        .dataType(DataType.VarChar)
        .maxLength(512)
        .build());

schema.addField(AddFieldReq.builder()
        .fieldName("vector")
        .dataType(DataType.FloatVector)
        .dimension(768)
        .build());

步骤 3：创建索引

为了提高查询效率，我们需要为 id 和 vector 字段创建索引。Milvus 支持多种索引类型，这里我们使用 Cosine 相似度作为度量方式。

IndexParam indexParamForIdField = IndexParam.builder()
        .fieldName("id")
        .indexType(IndexParam.IndexType.STL_SORT)
        .build();

IndexParam indexParamForVectorField = IndexParam.builder()
        .fieldName("vector")
        .indexType(IndexParam.IndexType.AUTOINDEX)
        .metricType(IndexParam.MetricType.COSINE)
        .build();

List<IndexParam> indexParams = new ArrayList<>();
indexParams.add(indexParamForIdField);
indexParams.add(indexParamForVectorField);

步骤 4：插入向量数据

接下来，我们使用 Ollama 提供的 API 将文本转换为向量，并将这些向量插入到 Milvus 中。

String[] textArray = {"Hello, this is a test.", "Milvus is great for vector search.", "Ollama helps in text embedding."};

List<float[]> vectors = new ArrayList<>();
for (String text : textArray) {
    // 调用 Ollama API 获取文本向量
    float[] vector = getTextEmbeddingFromOllama(OLLAMA_API_URL, text);
    vectors.add(vector);
}

// 将文本和向量组合成 JSON 格式的插入数据
List<JsonObject> data = new ArrayList<>();
for (int i = 0; i < vectors.size(); i++) {
    JsonObject jsonObject = new JsonObject();
    jsonObject.addProperty("id", i);
    jsonObject.add("vector", gson.toJsonTree(vectors.get(i)));
    jsonObject.addProperty("text", textArray[i]);
    data.add(jsonObject);
}

InsertReq insertReq = InsertReq.builder()
        .collectionName("milvus_example")
        .data(data)
        .build();

client.insert(insertReq);
System.out.println("Vectors inserted successfully into Milvus!");

步骤 5：进行相似度查询

最后，我们通过向量进行相似度查询。我们向 Milvus 提交一个查询向量，查询与之最相似的文本。

float[] queryVector = getTextEmbeddingFromOllama(OLLAMA_API_URL, "what about Milvus?");
FloatVec queryVectorFloatVec = new FloatVec(queryVector);

SearchReq searchReq = SearchReq.builder()
        .collectionName("milvus_example")
        .topK(1)  // 获取最相似的 1 个结果
        .metricType(IndexParam.MetricType.COSINE)  // 使用余弦相似度
        .data(Collections.singletonList(queryVectorFloatVec))
        .outputFields(Collections.singletonList("text"))
        .build();

SearchResp searchResp = client.search(searchReq);
if (searchResp != null
        && searchResp.getSearchResults() != null
        && !searchResp.getSearchResults().get(0).isEmpty()
        && searchResp.getSearchResults().get(0).get(0).getEntity() != null) {
    System.out.println("Search Results: " + gson.toJson(searchResp.getSearchResults().get(0).get(0).getEntity()));
} else {
    System.out.println("Search Results: null");
}

步骤 6：获取 Ollama 文本向量

为了获取文本的向量，我们调用 Ollama 的 Embedding API。通过向其发送请求，我们可以获得文本的嵌入向量。

public static float[] getTextEmbeddingFromOllama(String apiUrl, String text) {
    try {
        // 构造请求体
        JsonObject requestBody = new JsonObject();
        JsonArray inputArray = new JsonArray();
        inputArray.add(text);
        requestBody.add("input", inputArray);
        requestBody.addProperty("model", "nomic-embed-text");

        // 创建 OkHttp 请求
        RequestBody body = RequestBody.create(
                okhttp3.MediaType.parse("application/json; charset=utf-8"),
                gson.toJson(requestBody)
        );

        OkHttpClient client = new OkHttpClient();

        Request request = new Request.Builder()
                .url(apiUrl)
                .post(body)
                .build();

        // 执行请求并获取响应
        Response response = client.newCall(request).execute();
        if (!response.isSuccessful()) {
            System.out.println("Request failed: " + response.code());
            return new float[0];
        }

        // 解析响应数据
        String responseBody = response.body().string();
        JsonObject jsonResponse = gson.fromJson(responseBody, JsonObject.class);
        JsonArray embeddingsArray = jsonResponse.getAsJsonArray("data")
                .get(0).getAsJsonObject().getAsJsonArray("embedding");

        // 将嵌入向量转换为 float 数组
        float[] vector = new float[embeddingsArray.size()];
        for (int i = 0; i < embeddingsArray.size(); i++) {
            vector[i] = embeddingsArray.get(i).getAsFloat();
        }

        return vector;

    } catch (IOException e) {
        e.printStackTrace();
        return new float[0];
    }
}

完整代码实例

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.service.collection.request.CreateCollectionReq;
import io.milvus.v2.service.collection.request.AddFieldReq;
import io.milvus.v2.common.DataType;
import io.milvus.v2.common.IndexParam;
import io.milvus.v2.service.collection.request.DescribeCollectionReq;
import io.milvus.v2.service.collection.request.HasCollectionReq;
import io.milvus.v2.service.vector.request.InsertReq;
import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.request.data.FloatVec;
import io.milvus.v2.service.vector.response.SearchResp;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MilvusOllamaExample {

    private static final Gson gson = new Gson();

    public static void main(String[] args) {

        // Milvus 集群的连接配置
        String CLUSTER_ENDPOINT = "http://localhost:19530";
        String TOKEN = "root:Milvus";

        // Ollama 的 Embedding API 端点
        String OLLAMA_API_URL = "http://localhost:11434/v1/embeddings";

        String CLLECTION_NAME = "milvus_example";

        // 1. 连接到 Milvus 服务器
        ConnectConfig connectConfig = ConnectConfig.builder()
                .uri(CLUSTER_ENDPOINT)
                .token(TOKEN)
                .build();

        MilvusClientV2 client = new MilvusClientV2(connectConfig);

        // 检查并删除现有集合（如果存在）
        if (client.hasCollection(HasCollectionReq.builder().collectionName(CLLECTION_NAME).build())) {
            client.describeCollection(DescribeCollectionReq.builder().collectionName(CLLECTION_NAME).build());
            System.out.println("Collection deleted successfully!");
        }

        try {
            // 2. 创建 schema
            CreateCollectionReq.CollectionSchema schema = client.createSchema();

            // 2.1 添加字段到 schema
            schema.addField(AddFieldReq.builder()
                    .fieldName("id")
                    .dataType(DataType.Int64)
                    .isPrimaryKey(true)
                    .autoID(false)
                    .build());

            schema.addField(AddFieldReq.builder()
                    .fieldName("text")
                    .dataType(DataType.VarChar)
                    .maxLength(512)  // 设置 varchar 字段最大长度
                    .build());

            schema.addField(AddFieldReq.builder()
                    .fieldName("vector")
                    .dataType(DataType.FloatVector)
                    .dimension(768)  // 设置向量维度
                    .build());

            // 3. 准备索引参数
            IndexParam indexParamForIdField = IndexParam.builder()
                    .fieldName("id")
                    .indexType(IndexParam.IndexType.STL_SORT)
                    .build();

            IndexParam indexParamForVectorField = IndexParam.builder()
                    .fieldName("vector")
                    .indexType(IndexParam.IndexType.AUTOINDEX)
                    .metricType(IndexParam.MetricType.COSINE)  // 使用 COSINE 相似度
                    .build();

            List<IndexParam> indexParams = new ArrayList<>();
            indexParams.add(indexParamForIdField);
            indexParams.add(indexParamForVectorField);

            // 4. 创建集合并设置索引
            CreateCollectionReq customizedSetupReq1 = CreateCollectionReq.builder()
                    .collectionName("milvus_example")
                    .collectionSchema(schema)
                    .indexParams(indexParams)
                    .build();

            client.createCollection(customizedSetupReq1);
            System.out.println("Collection created successfully!");

            // 5. 使用 Ollama 获取文本向量
            String[] textArray = {"Hello, this is a test.", "Milvus is great for vector search.", "Ollama helps in text embedding."};

            List<float[]> vectors = new ArrayList<>();
            for (String text : textArray) {
                // 调用 Ollama API 获取文本向量
                float[] vector = getTextEmbeddingFromOllama(OLLAMA_API_URL, text);
                vectors.add(vector);
            }

            // 6. 插入向量到 Milvus
            List<Long> ids = new ArrayList<>();
            for (int i = 0; i < textArray.length; i++) {
                ids.add((long) i);  // 简单地用索引作为 ID
            }

            // 将文本和向量组合成 JSON 格式的插入数据
            List<JsonObject> data = new ArrayList<>();
            for (int i = 0; i < vectors.size(); i++) {
                JsonObject jsonObject = new JsonObject();
                jsonObject.addProperty("id", i);
                jsonObject.add("vector", gson.toJsonTree(vectors.get(i)));
                jsonObject.addProperty("text", textArray[i]);
                data.add(jsonObject);
            }

            InsertReq insertReq = InsertReq.builder()
                    .collectionName("milvus_example")
                    .data(data)
                    .build();

            client.insert(insertReq);
            System.out.println("Vectors inserted successfully into Milvus!");

            // 7. 创建查询向量并执行搜索
            float[] queryVector = getTextEmbeddingFromOllama(OLLAMA_API_URL, "what about Milvus?");
            FloatVec queryVectorFloatVec = new FloatVec(queryVector);

            // 创建查询请求
            SearchReq searchReq = SearchReq.builder()
                    .collectionName("milvus_example")
                    .topK(1)  // 获取最相似的 1 个结果
                    .metricType(IndexParam.MetricType.COSINE)  // 使用余弦相似度
                    .data(Collections.singletonList(queryVectorFloatVec))
                    .outputFields(Collections.singletonList("text"))
                    .build();

            // 执行查询操作
            SearchResp searchResp = client.search(searchReq);
            if (searchResp != null
                    && searchResp.getSearchResults() != null
                    && !searchResp.getSearchResults().get(0).isEmpty()
                    && searchResp.getSearchResults().get(0).get(0).getEntity() != null) {
                System.out.println("Search Results: " + gson.toJson(searchResp.getSearchResults().get(0).get(0).getEntity()));
            } else {
                System.out.println("Search Results: null");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 8. 关闭 Milvus 客户端连接
            client.close();
        }
    }

    // 调用 Ollama API 获取文本的向量
    public static float[] getTextEmbeddingFromOllama(String apiUrl, String text) {
        try {
            // 构造请求体
            JsonObject requestBody = new JsonObject();
            JsonArray inputArray = new JsonArray();
            inputArray.add(text);
            requestBody.add("input", inputArray);
            requestBody.addProperty("model", "nomic-embed-text");

            // 创建 OkHttp 请求
            RequestBody body = RequestBody.create(
                    okhttp3.MediaType.parse("application/json; charset=utf-8"),
                    gson.toJson(requestBody)
            );

            OkHttpClient client = new OkHttpClient();

            Request request = new Request.Builder()
                    .url(apiUrl)
                    .post(body)
                    .build();

            // 执行请求并获取响应
            Response response = client.newCall(request).execute();
            if (!response.isSuccessful()) {
                System.out.println("Request failed: " + response.code());
                return new float[0];
            }

            // 解析响应数据
            String responseBody = response.body().string();
            JsonObject jsonResponse = gson.fromJson(responseBody, JsonObject.class);
            JsonArray embeddingsArray = jsonResponse.getAsJsonArray("data")
                    .get(0).getAsJsonObject().getAsJsonArray("embedding");

            // 将嵌入向量转换为 float 数组
            float[] vector = new float[embeddingsArray.size()];
            for (int i = 0; i < embeddingsArray.size(); i++) {
                vector[i] = embeddingsArray.get(i).getAsFloat();
            }

            return vector;

        } catch (IOException e) {
            e.printStackTrace();
            return new float[0];
        }
    }
}

总结

通过本示例，我们展示了如何结合 Milvus 和 Ollama 完成文本向量的存储和相似度检索。Milvus 提供了强大的向量存储和检索功能，而 Ollama 则通过其 API 提供了高效的文本嵌入服务。两者的结合，使得构建文本搜索系统变得更加高效和简单。

希望这篇博客对你有所帮助，如果你有任何问题，欢迎在评论区留言！

基于ollama本地模型处理数据生成嵌入向量插入进milvus向量数据库
wjylovewjy的博客
04-17 488
博主使用ollama调用gte-large-zh:latest模型处理json数据，生成嵌入变量，并存储进milvus向量数据库中。
使用Ollama和Go基于文本嵌入模型实现文本向量化
TonyBai
05-09 2913
基于RAG+大模型的应用已经成为当前AI应用领域的一个热门方向。RAG(Retrieval-Augmented Generation)将检索和生成两个步骤相结合，利用外部知识库来增强生成模型的能力(如下图来自网络)。在RAG赋能的大模型应用中，关键的一步是将文本数据向量化后存储在向量数据库中(如上图的红框)，以实现快速的相似度搜索，从而检索与输入查询相关的文本片段，再将检索到的文本输入给生成模型生...
Java + Ollama + DeepSeek + Milvus：构建私有知识库问答系统
weixin_44385380的博客
02-28 2158
我们将实现一个系统，该系统能够：使用 Ollama 提供的文本嵌入功能，将文本转换为向量。将这些向量存储在 Milvus 向量数据库中。使用 DeepSeek 模型根据用户问题生成回答。结合 Milvus 中存储的私有知识库，提供更准确的问答服务。通过结合 Java、Ollama、DeepSeek 和 Milvus，我们成功构建了一个基于私有知识库的问答系统。Milvus 提供了高效的向量存储和检索功能，Ollama 提供了强大的文本嵌入服务，而 DeepSeek 则负责生成自然语言回答。
【人工智能】文本嵌入：向量存储与数据查询的智慧交织(12)
龚小帅的博客
02-06 820
因为中文是及其复杂的，并且语义内容十分丰富，所以需要进行词汇拆分，最常用的就是 RecursiveCharacterTextSplitter 分词器，这里重点关注按照字符递归拆分方式 RecursiveCharacterTextSplitter ，这种方式会将语义最相关的文本片段放在一起。一个用于嵌入查询，接受单个文本。最后一点就是自查询（SelfQueryRetriever）的概念，其实就是结构化查询元数据，因为对文档的元信息查询和文档内容的概要描述部分查询效率肯定是高于全部文档的。
使用KDBAI Vector Store进行文本向量存储和查询
qq_29929123的博客
07-19 426
KDBAI Vector Store是一个基于KDB.AI的向量存储解决方案。在这个存储中，我们可以将文本、其嵌入和元数据存储在KDBAI的表格中。这种设计允许我们使用已经存在的表格进行操作，从而提高数据管理的灵活性。
langchain 文本向量化存储，并检索相似 topK，检索方法汇总
木下瞳的博客
04-13 7784
txt 有多行，我的这份数据有 67 行，样例如下：字段1\t值1\n字段2\t值2\n...
基于Python将MongoDB文本数据通过text2vec-large-chinese模型向量化并存储到Milvus数据库的完整实现方案
最新发布
朴拙科技的博客
04-23 763
通过上述方案，可实现MongoDB文本数据向Milvus的高效迁移。如需处理超大规模数据（百万级以上），建议采用Milvus的Bulk Insert功能直接导入预处理好的Parquet文件。• GPU加速：启用CUDA加速模型推理（需NVIDIA GPU环境）。以下是基于Python将MongoDB文本数据通过。• 元数据过滤：在Milvus搜索时添加。一、实现流程与代码解析。• 若使用其他模型（如。值（例如768维）。
milvus 结合Thowee 文本转向量 ,新建表,存储,搜索，删除
qq_56352553的博客
09-30 1600
【代码】milvus 结合Thowee 文本转向量 ,新建表,存储,搜索，删除。
手把手系列 ｜ 使用Milvus、Llama 3、Ollama、LangChain本地设置RAG应用
ZILLIZ
08-20 1224
随着 Llama、Mistral、Gemma 等开源大语言模型（LLM）的出现，我们越来越能感受到 LLM 的力量，而本地运行基于 LLM 的 RAG 应用的需求越来越强烈。在将应用推至生产环境前，我们往往都需要先本地运行和测试。因此，本文将介绍如何使用 Ollama、Llama 3 和 Milvus 向量数据库在本地部署一个检索增强生成（RAG）应用。本文将使用到的软件和工具包括：LangCha...
使用 Ollama、Llama 3.1 和 Milvus 进行函数调用案例
qq_29883477的博客
08-28 2065
像 GPT-4、Mistral Nemo 和 Llama 3.1 这样的 LLM 现在可以检测到它们需要调用函数时，然后输出包含用于调用该函数的参数的JSON。这使得您的 AI 应用更加通用和强大。由 LLM 提供支持的数据提取和标记解决方案（例如，从维基百科文章中提取人物姓名）可以帮助将自然语言转换为 API 调用或有效数据库查询的应用程序与知识库交互的对话式知识检索引擎Ollama：将 LLM 的强大功能带到您的笔记本电脑上，简化本地操作。
Milvus ollama
03-20
Milvus作为高效的向量数据库，与Ollama（本地化运行大语言模型的工具）的集成主要用于**文本向量生成与检索场景**。以下是具体实现步骤： --- #### 1. **核心逻辑** - **Ollama**：负责将文本转换为向量...
基于Langchain、Ollama、Milvus构建RAG demo案例
zsjdhr的博客
02-16 247
本案例以弱智吧问答对为材料，进行向量转化存储，文件格式为json。
RAG怎么向量化？向量化文件存放在哪里？Ollama deepseek-R1 1.5b
u013302168的博客
02-11 2331
在构建基于 RAG（Retrieval-Augmented Generation）的系统时，向量化是核心步骤之一。它涉及将文本数据转换为数值向量，以便能够高效地进行相似性搜索和检索。以下是关于如何向量化以及向量化文件存放位置的详细说明。向量化的核心是将文本数据转化为高维向量表示（Embedding）。通常使用预训练的语言模型来生成这些向量。： 使用 Milvus 等向量数据库存储向量，参考前面的示例代码。生成的向量需要存储以便后续检索。接口，可以用于生成文本嵌入向量。Ollama 提供了。
Milvus 本地Ollama向量化markdown文件
qq_32860767的博客
12-20 730
我在局域网内安装了milvus服务，现在需要把一个文件夹里所有的markdown文档都向量化到milvus数据库中。所用的切分方法是langchain中自带的markdown按照标题切分，且带有标题的metadata，非常清晰。但是用langchain提供的milvus向量化的时候遇到很多麻烦的错误也很难追寻。最后决定还是用自带的pymilvus做，效果相当好。
大模型入门到进阶！手把手教你使用Milvus、Llama 3、Ollama、LangChain本地设置RAG应用
老皮的博客
10-15 1013
AI大模型作为人工智能领域的重要技术突破，正成为推动各行各业创新和转型的关键力量。抓住AI大模型的风口，掌握AI大模型的知识和技能将变得越来越重要。学习AI大模型是一个系统的过程，需要从基础开始，逐步深入到更高级的技术。这里给大家精心整理了一份全面的AI大模型学习资源，包括：AI大模型全套学习路线图（从入门到实战）、精品AI大模型学习书籍手册、视频教程、实战学习、面试题等，资料免费分享！
Meilisearch 和 Ollama 实现文本向量搜索
python1234_的博客
10-09 1758
Meilisearch 是一个开源、快速、简洁的全文搜索引擎，专为构建高性能、实时的搜索功能而设计。其主要特点如下：极速搜索：Meilisearch 使用反向索引来加速搜索查询，因此能够在海量数据中提供毫秒级的响应时间，尤其适合实时搜索需求。智能搜索：Meilisearch 支持模糊搜索、拼写纠错、同义词匹配、结果排序等功能，使得用户在搜索时无需提供完全准确的关键词。即时更新：它支持对数据的实时更新，任何数据变动都会立即反映在搜索结果中，适合频繁变动的数据集。
第13篇：Milvus在自然语言处理中的向量检索
Gemini的博客
06-13 1506
文本向量化：选择合适的文本向量化技术，将文本转换为向量。数据存储：将向量化后的文本存储到Milvus中。向量检索：实现基于Milvus的向量检索功能。应用集成：将检索结果集成到实际应用中。通过这篇博客，我们详细介绍了文本向量化技术及其在自然语言处理中的应用，并展示了如何将NLP与Milvus结合，实现高效的向量检索。我们从需求分析开始，逐步讲解了文本向量化、数据存储、向量检索和应用集成的详细步骤，并提供了相应的Java代码示例。
探索Ollama Embeddings：开启文本向量化的新篇章
mmlihaio的博客
11-11 2648
Ollama Embeddings提供了强大的文本向量化功能，是自然语言处理任务中不可或缺的工具。无论是文本分类、主题建模还是信息检索，理解和使用这样的嵌入技术都是非常重要的。
Win10（CPU）+ Anaconda3 + python3.9安装pytorch
AAI666666的博客
01-14 1989
Win10（CPU）+ Anaconda3 + python3.9安装pytorch
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值