Weaviate 实战指南:从零构建AI驱动的向量搜索应用

Weaviate vs Milvus:哪款向量数据库更适合你的需求 Milvus 是一款高性能、云原生的开源向量数据库,致力于提供快速、可扩展的向量搜索能力。它支持多种索引类型,允许开发者根据需求选择最优的索引策略,并具有强大的可扩展性。 阅读详情

1. 为什么你需要一个AI原生的向量数据库?

如果你正在开发一个智能客服系统,用户问“我的订单物流卡住了怎么办”,传统的数据库只能匹配“订单”、“物流”、“卡住”这些关键词,可能会返回一堆不相关的帮助文档。但如果你用上了向量搜索,它能理解这句话背后的语义是“查询物流异常并寻求解决方案”,直接找到最相关的“物流异常处理流程”文档。这种“理解”能力,就是AI原生向量数据库带来的质变。

我刚开始接触AI应用开发时,也踩过不少坑。最早尝试用传统数据库+外挂向量索引的方式,光是处理数据同步和一致性就头大,更别提应对高并发查询了。后来试了几个专门的向量数据库,最终发现Weaviate在易用性、功能完整性和生产就绪度上找到了一个很好的平衡点。它不像有些方案那样需要你成为分布式系统专家才能上手,也不像另一些那样功能简陋到只能做最简单的相似度匹配。

简单来说,Weaviate就是一个专门为AI应用设计的数据库,它最擅长的事情就是把你的文本、图片、音频等各种非结构化数据转换成数学向量,然后在这些向量空间里做快速、精准的语义搜索。你可以把它想象成一个拥有“理解能力”的智能搜索引擎内核,而不仅仅是关键词匹配工具。

在实际项目中,我主要会在这些场景下选择Weaviate:一是构建RAG(检索增强生成)系统,让大模型回答问题时能准确引用你的内部知识库,大幅减少“幻觉”;二是做智能推荐和内容发现,比如根据用户历史行为推荐相似商品或文章;三是多模态搜索,比如用一张图片找到相似的图片,或者用一段描述找到对应的图片。它的混合搜索能力特别实用,既能理解语义,又不丢掉传统关键词过滤的精准性。

2. 5分钟快速上手:本地开发环境搭建

很多教程一上来就让你配置一堆复杂的环境变量和依赖,容易劝退新手。我这里分享一个最简化的本地启动方案,只需要Docker,不需要安装Python环境或其他复杂工具。

首先确保你的机器上已经安装了Docker和Docker Compose。如果还没装,去Docker官网下载对应你操作系统的安装包,通常一路下一步就能搞定。安装完成后,打开终端运行docker --version和docker compose version确认安装成功。

接下来创建一个项目目录,比如叫weaviate-demo,然后在里面创建一个docker-compose.yml文件。这个文件定义了Weaviate服务及其配置:

version: '3.4'
services:
  weaviate:
    command:
      - --host
      - 0.0.0.0
      - --port
      - '8080'
      - --scheme
      - http
    image: cr.weaviate.io/semitechnologies/weaviate:1.33.1
    ports:
      - 8080:8080
      - 50051:50051
    volumes:
      - ./weaviate_data:/var/lib/weaviate
    restart: unless-stopped
    environment:
      QUERY_DEFAULTS_LIMIT: 20
      AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true'
      PERSISTENCE_DATA_PATH: '/var/lib/weaviate'
      CLUSTER_HOSTNAME: 'node1'
      ENABLE_MODULES: 'text2vec-openai,generative-openai'
      DEFAULT_VECTORIZER_MODULE: 'text2vec-openai'

这个配置做了几件重要的事情:第一,它启用了匿名访问(仅限开发环境,生产环境一定要改掉);第二,它挂载了本地目录weaviate_data来持久化数据,这样重启容器后数据不会丢失;第三,它启用了OpenAI的文本向量化模块和生成模块,这样Weaviate就能自动调用OpenAI的API来把文本转换成向量。

保存文件后,在终端里进入项目目录,运行docker compose up -d。你会看到Docker开始拉取镜像并启动容器。等个几十秒,用浏览器打开http://localhost:8080/v1/meta,如果看到返回的JSON信息,说明Weaviate已经成功运行了。

注意:如果你在中国大陆,可能会遇到拉取Docker镜像慢的问题。可以配置Docker镜像加速器,或者把镜像地址换成国内的镜像源。另外,这个配置需要访问OpenAI的API,确保你的网络环境能够正常访问。

现在你已经有了一个运行中的Weaviate实例!但为了后续的代码操作,我们还需要准备Python环境。创建一个requirements.txt文件,里面写上:

weaviate-client>=4.0.0
openai>=1.0.0
python-dotenv>=1.0.0

然后运行pip install -r requirements.txt安装依赖。这里我强烈建议使用虚拟环境,可以用python -m venv venv创建,然后用source venv/bin/activate(Linux/Mac)或venv\Scripts\activate(Windows)激活。

最后创建一个.env文件来管理敏感信息:

OPENAI_API_KEY=你的OpenAI_API密钥
WEAVIATE_URL=http://localhost:8080

这样基础环境就搭建完成了。整个过程如果顺利的话,5分钟真的够用。我第一次搭建时因为网络问题花了些时间,但第二次在另一台机器上重试,确实就是5分钟的事。

3. 数据建模与导入:从零创建你的第一个向量集合

很多人在刚开始用向量数据库时,最容易犯的错误就是直接照搬传统数据库的表结构设计思路。向量数据库的数据建模有自己的特点,需要同时考虑搜索效率、语义理解和业务需求。

在Weaviate里,数据组织的基本单位叫“集合”(Collection),相当于传统数据库里的表。每个集合包含多个“对象”(Object),每个对象有属性(Properties)和一个向量(Vector)。让我用一个实际的例子来说明:假设我们要构建一个智能文档检索系统,存放技术文章。

首先,我们来设计集合结构。技术文章通常有标题、内容、作者、标签、发布时间等字段。但在向量数据库里,我们需要特别考虑:哪些字段需要被向量化(用于语义搜索)?哪些字段只需要做过滤(比如按作者筛选)?哪些字段需要全文索引(用于关键词搜索)?

import weaviate
import os
from dotenv import load_dotenv

load_dotenv()

client = weaviate.connect_to_local(
    host="localhost",
    port=8080,
    grpc_port=50051,
)

# 定义文章集合的结构
article_collection = client.collections.create(
    name="Article",
    description="技术文章集合",
    vectorizer_config=weaviate.classes.config.Configure.Vectorizer.text2vec_openai(),
    generative_config=weaviate.classes.config.Configure.Generative.openai(),
    properties=[
        weaviate.classes.config.Property(
            name="title",
            data_type=weaviate.classes.config.DataType.TEXT,
            description="文章标题",
            # 这个字段既要做向量搜索,也要做关键词过滤
            vectorize_property_name=True,
            index_filterable=True,
            index_searchable=True,
        ),
        weaviate.classes.config.Property(
            name="content",
            data_type=weaviate.classes.config.DataType.TEXT,
            description="文章内容",
            # 内容是最重要的搜索字段,需要向量化
            vectorize_property_name=True,
            index_filterable=True,
            index_searchable=True,
        ),
        weaviate.classes.config.Property(
            name="author",
            data_type=weaviate.classes.config.DataType.TEXT,
            description="作者",
            # 作者字段通常只用于过滤,不需要向量化
            vectorize_property_name=False,
            index_filterable=True,
            index_searchable=False,
        ),
        weaviate.classes.config.Property(
            name="tags",
            data_type=weaviate.classes.config.DataType.TEXT_ARRAY,
            description="文章标签",
            # 标签数组,用于多值过滤
            vectorize_property_name=False,
            index_filterable=True,
            index_searchable=True,
        ),
        weaviate.classes.config.Property(
            name="publish_date",
            data_type=weaviate.classes.config.DataType.DATE,
            description="发布日期",
            # 日期字段用于范围过滤
            index_filterable=True,
            index_searchable=False,
        ),
        weaviate.classes.config.Property(
            name="view_count",
            data_type=weaviate.classes.config.DataType.INT,
            description="阅读量",
            # 数值字段用于排序和过滤
            index_filterable=True,
            index_searchable=False,
        ),
    ]
)

print(f"集合 '{article_collection.name}' 创建成功!")

这里有几个关键设计决策需要解释:vectorize_property_name决定这个字段是否参与向量化,对于author这种专有名词,向量化可能反而会引入噪声,所以设为False。index_filterable允许这个字段用于过滤查询,比如author="张三"。index_searchable允许这个字段用于BM25关键词搜索。

集合创建好后,接下来是导入数据。我见过不少人直接用单条插入的方式,导入几万条数据花了半小时。其实Weaviate有很高效的批量导入机制:

# 准备一些示例数据
articles_data = [
    {
        "title": "深度学习在自然语言处理中的应用",
        "content": "近年来,基于Transformer的预训练语言模型在NLP领域取得了突破性进展...",
        "author": "李华",
        "tags": ["深度学习", "NLP", "Transformer"],
        "publish_date": "2024-01-15T10:30:00Z",
        "view_count": 1500
    },
    {
        "title": "微服务架构的设计原则",
        "content": "微服务架构通过将单体应用拆分为多个小型服务来提高系统的可维护性和可扩展性...",
        "author": "王明",
        "tags": ["架构", "微服务", "分布式系统"],
        "publish_date": "2024-02-20T14:45:00Z",
        "view_count": 3200
    },
    {
        "title": "React Hooks最佳实践",
        "content": "Hooks是React 16.8引入的新特性,它让函数组件也能使用状态和生命周期方法...",
        "author": "张伟",
        "tags": ["前端", "React", "JavaScript"],
        "publish_date": "2024-03-10T09:15:00Z",
        "view_count": 2800
    },
    {
        "title": "Python异步编程详解",
        "content": "asyncio是Python中用于编写并发代码的库,使用async/await语法...",
        "author": "李华",
        "tags": ["Python", "异步编程", "asyncio"],
        "publish_date": "2024-03-25T16:20:00Z",
        "view_count": 2100
    },
    {
        "title": "容器化部署的CI/CD流水线",
        "content": "结合Docker和Kubernetes,我们可以构建自动化的持续集成和持续部署流程...",
        "author": "赵雷",
        "tags": ["DevOps", "Docker", "Kubernetes", "CI/CD"],
        "publish_date": "2024-04-05T11:10:00Z",
        "view_count": 1800
    }
]

# 批量导入数据
with article_collection.batch.dynamic() as batch:
    for i, article in enumerate(articles_data):
        batch.add_object(
            properties=article,
            # 这里可以显式指定向量,如果使用vectorizer则会自动生成
            # vector=your_custom_vector
        )
        # 每处理100条数据打印一次进度
        if i % 100 == 0 and i > 0:
            print(f"已导入 {i} 条数据")

print("数据导入完成!")

批量导入时,batch.dynamic()会自动管理批次大小和重试逻辑,这是生产环境的最佳实践。如果数据量很大(比如超过10万条),我建议还要加上错误处理和进度监控。实际项目中,我通常会从数据库导出数据,或者从文件系统读取文档,然后转换成这种结构导入。

导入完成后,可以用这个简单的方法验证数据是否成功:

# 验证数据导入
count = article_collection.aggregate.over_all(total_count=True).total_count
print(f"集合中总共有 {count} 篇文章")

# 查看前几条数据
response = article_collection.query.fetch_objects(limit=3)
for obj in response.objects:
    print(f"标题: {obj.properties['title']}")
    print(f"作者: {obj.properties['author']}")
    print(f"标签: {obj.properties['tags']}")
    print("-" * 50)

如果一切正常,你应该能看到导入的数据。这时候数据已经自动向量化了,Weaviate会调用OpenAI的嵌入模型为title和content字段生成向量表示。这个过程是异步的,但对于小批量数据,几乎是瞬间完成的。

4. 核心搜索实战:纯向量、关键词与混合搜索

数据准备好了,现在进入最核心的部分:搜索。Weaviate提供了三种主要的搜索方式,每种都有其适用场景,我结合实际使用经验来详细说说。

4.1 纯向量搜索:理解语义的魔法

纯向量搜索是Weaviate的看家本领,它不关心关键词是否匹配,只关心语义是否相似。这特别适合那些用户表达和文档表述不一致的场景。

# 纯向量搜索示例
def pure_vector_search(query_text, limit=3):
    """执行纯向量搜索"""
    response = article_collection.query.near_text(
        query=query_text,
        limit=limit,
        # 控制搜索的确定性,越高结果越稳定但可能错过相关结果
        certainty=0.7,
        # 返回向量距离,用于评估相似度
        return_metadata=weaviate.classes.query.MetadataQuery(distance=True)
    )
    
    print(f"\n🔍 纯向量搜索: '{query_text}'")
    print("=" * 60)
    
    for i, obj in enumerate(response.objects):
        distance = obj.metadata.distance if obj.metadata else "N/A"
        print(f"\n结果 {i+1} (距离: {distance:.4f}):")
        print(f"标题: {obj.properties['title']}")
        print(f"作者: {obj.properties['author']}")
        # 显示内容片段
        content_preview = obj.properties['content'][:100] + "..." if len(obj.properties['content']) > 100 else obj.properties['content']
        print(f"内容: {content_preview}")
        print(f"标签: {', '.join(obj.properties['tags'])}")
    
    return response.objects

# 测试几个查询
test_queries = [
    "如何学习人工智能",  # 广义查询
    "前端开发的最新趋势",  # 领域特定查询
    "Docker容器编排",  # 技术术语查询
]

for query in test_queries:
    results = pure_vector_search(query)

这里有个很重要的参数certainty,它控制搜索的“严格程度”。值越高(接近1),要求匹配度越高,结果越精准但可能漏掉一些相关结果;值越低(接近0),结果越多但可能包含不相关的内容。我一般从0.7开始调整,根据实际效果微调。

纯向量搜索的优点是它能找到那些字面上不匹配但语义相关的文档。比如搜索“如何学习AI”,即使文档里写的是“人工智能入门指南”也能被找到。但它的缺点也很明显:如果用户输入的关键词非常具体准确,纯向量搜索可能不如关键词搜索直接。

4.2 关键词搜索:传统但精准

关键词搜索基于BM25算法,这是搜索引擎的经典算法。当用户查询非常具体,或者你需要精确匹配某些术语时,关键词搜索往往更有效。

# 关键词搜索(BM25)示例
def keyword_search(query_text, limit=3):
    """执行关键词搜索"""
    response = article_collection.query.bm25(
        query=query_text,
        limit=limit,
        # 可以指定在哪些字段上搜索
        query_properties=["title", "content", "tags"],
        # 返回相关性分数
        return_metadata=weaviate.classes.query.MetadataQuery(score=True)
    )
    
    print(f"\n🔍 关键词搜索: '{query_text}'")
    print("=" * 60)
    
    for i, obj in enumerate(response.objects):
        score = obj.metadata.score if obj.metadata else "N/A"
        print(f"\n结果 {i+1} (BM25分数: {score:.4f}):")
        print(f"标题: {obj.properties['title']}")
        print(f"作者: {obj.properties['author']}")
        # 高亮匹配的关键词(简单实现)
        content = obj.properties['content']
        for word in query_text.split():
            if word.lower() in content.lower():
                content = content.replace(word, f"**{word}**")
        content_preview = content[:150] + "..." if len(content) > 150 else content
        print(f"内容: {content_preview}")
    
    return response.objects

# 测试关键词搜索
keyword_queries = [
    "Docker Kubernetes",  # 具体技术栈
    "React Hooks",  # 具体功能
    "Python asyncio",  # 具体库名
]

for query in keyword_queries:
    results = keyword_search(query)

关键词搜索特别适合技术文档检索,因为技术术语通常有明确的定义,用户也倾向于使用准确的术语搜索。但它的局限性在于无法处理同义词和语义扩展,比如搜索“机器学习”就找不到“ML”或“人工智能”的相关内容,除非文档里明确包含了“机器学习”这个词。

4.3 混合搜索:两全其美的解决方案

混合搜索是我在实际项目中最常用的功能,它结合了向量搜索的语义理解能力和关键词搜索的精确匹配能力。Weaviate使用RRF(倒数排名融合)算法来合并两种搜索的结果。

# 混合搜索示例
def hybrid_search(query_text, alpha=0.5, limit=5):
    """
    执行混合搜索
    
    参数:
    - query_text: 查询文本
    - alpha: 向量搜索的权重(0-1),0.5表示两者平衡
    - limit: 返回结果数量
    """
    response = article_collection.query.hybrid(
        query=query_text,
        alpha=alpha,
        limit=limit,
        # 可以分别配置向量和关键词搜索的属性
        vector_search_config=weaviate.classes.query.HybridVectorSearch(
            vectorize_query=True,  # 是否向量化查询
            target_vector="default",  # 使用哪个向量
        ),
        keyword_search_config=weaviate.classes.query.HybridKeywordSearch(
            query_properties=["title", "content", "tags"],
        ),
        # 返回融合分数
        return_metadata=weaviate.classes.query.MetadataQuery(
            score=True,
            explain_score=True  # 解释分数计算过程
        )
    )
    
    print(f"\n🔍 混合搜索 (alpha={alpha}): '{query_text}'")
    print("=" * 60)
    
    for i, obj in enumerate(response.objects):
        metadata = obj.metadata
        print(f"\n结果 {i+1} (总分: {metadata.score:.4f}):")
        print(f"标题: {obj.properties['title']}")
        print(f"作者: {obj.properties['author']}")
        
        # 如果有解释信息,显示向量和关键词分数
        if metadata.explain_score:
            vector_score = getattr(metadata.explain_score, 'vector_score', 'N/A')
            keyword_score = getattr(metadata.explain_score, 'keyword_score', 'N/A')
            print(f"向量分数: {vector_score}, 关键词分数: {keyword_score}")
        
        # 显示标签和部分内容
        print(f"标签: {', '.join(obj.properties['tags'])}")
        content_preview = obj.properties['content'][:120] + "..." if len(obj.properties['content']) > 120 else obj.properties['content']
        print(f"内容: {content_preview}")
    
    return response.objects

# 测试混合搜索
hybrid_queries = [
    "异步编程在Python中的应用",  # 既有概念又有具体技术
    "微服务架构设计",  # 架构概念
    "前端框架React的使用技巧",  # 具体技术+使用场景
]

for query in hybrid_queries:
    # 尝试不同的alpha值
    for alpha in [0.2, 0.5, 0.8]:
        print(f"\n{'='*40}")
        print(f"测试 alpha = {alpha}")
        print('='*40)
        results = hybrid_search(query, alpha=alpha)

alpha参数控制向量搜索和关键词搜索的权重比例。alpha=1是纯向量搜索,alpha=0是纯关键词搜索,alpha=0.5是两者平衡。我通常的做法是:对于概念性、描述性的查询,用较高的alpha(0.7-0.9);对于具体的技术术语查询,用较低的alpha(0.3-0.5);对于一般性查询,用0.5。

混合搜索的强大之处在于它能同时捕获语义相关性和关键词匹配度。比如搜索“Python异步编程”,既可能找到标题包含“asyncio”的文章(关键词匹配),也可能找到内容讨论“协程”和“事件循环”的文章(语义匹配)。

4.4 带过滤的搜索:精准定位

在实际应用中,我们经常需要在特定范围内搜索,比如只搜索某个作者的文章,或者某个时间段内的文章。Weaviate的过滤功能非常强大:

# 带过滤的搜索示例
def filtered_search(query_text, filters=None, limit=3):
    """执行带过滤条件的搜索"""
    
    # 构建基础查询
    query_builder = article_collection.query.near_text(
        query=query_text,
        limit=limit,
        return_metadata=weaviate.classes.query.MetadataQuery(distance=True)
    )
    
    # 应用过滤条件
    if filters:
        query_builder = query_builder.with_where(filters)
    
    response = query_builder.do()
    
    print(f"\n🔍 带过滤的搜索: '{query_text}'")
    if filters:
        print(f"过滤条件: {filters}")
    print("=" * 60)
    
    for i, obj in enumerate(response.objects):
        distance = obj.metadata.distance if obj.metadata else "N/A"
        print(f"\n结果 {i+1} (距离: {distance:.4f}):")
        print(f"标题: {obj.properties['title']}")
        print(f"作者: {obj.properties['author']}")
        print(f"发布日期: {obj.properties['publish_date']}")
        print(f"阅读量: {obj.properties['view_count']}")
    
    return response.objects

# 测试各种过滤条件
from weaviate.classes.query import Filter

# 1. 按作者过滤
author_filter = Filter.by_property("author").equal("李华")
filtered_search("编程", author_filter)

# 2. 按标签过滤(多值)
tags_filter = Filter.by_property("tags").contains_any(["Python", "JavaScript"])
filtered_search("开发", tags_filter)

# 3. 按阅读量范围过滤
views_filter = Filter.by_property("view_count").greater_than(2000)
filtered_search("技术", views_filter)

# 4. 按日期范围过滤
from datetime import datetime
date_filter = Filter.by_property("publish_date").greater_or_equal(datetime(2024, 3, 1))
filtered_search("学习", date_filter)

# 5. 组合过滤条件
combined_filter = Filter.and_(
    Filter.by_property("author").equal("李华"),
    Filter.by_property("view_count").greater_than(1000),
    Filter.by_property("tags").contains_any(["Python", "深度学习"])
)
filtered_search("人工智能", combined_filter)

过滤条件可以组合使用,支持and、or、not等逻辑操作。这对于构建复杂的搜索界面特别有用,比如电商网站的商品筛选、内容管理系统的多条件查询等。

5. 构建生产级RAG应用:从检索到生成

RAG(检索增强生成)是当前AI应用的热门架构,它通过检索相关知识来增强大模型的回答准确性。Weaviate在这个场景中扮演着“知识库”的角色。让我带你从头构建一个完整的RAG系统。

5.1 RAG系统架构设计

一个完整的RAG系统通常包含以下几个组件:

  1. 文档加载与处理:从各种来源加载文档,进行清洗和分割
  2. 向量化与存储:将文档块转换为向量并存入Weaviate
  3. 检索模块:根据用户查询检索相关文档
  4. 生成模块:将检索到的文档作为上下文,生成回答
  5. 评估与优化:监控系统效果并持续改进

我们先从文档处理开始。假设我们有一些技术文档需要处理:

import re
from typing import List, Dict, Any
from dataclasses import dataclass

@dataclass
class DocumentChunk:
    """文档块数据结构"""
    content: str
    metadata: Dict[str, Any]
    chunk_id: str
    vector: List[float] = None

class DocumentProcessor:
    """文档处理器"""
    
    def __init__(self, chunk_size=500, chunk_overlap=50):
        self.chunk_size = chunk_size
        self.chunk_overlap = chunk_overlap
    
    def clean_text(self, text: str) -> str:
        """清理文本"""
        # 移除多余空白字符
        text = re.sub(r'\s+', ' ', text)
        # 移除特殊字符但保留标点
        text = re.sub(r'[^\w\s.,!?;:\-()\[\]{}]', '', text)
        return text.strip()
    
    def split_by_sentences(self, text: str) -> List[str]:
        """按句子分割文本"""
        # 简单的句子分割,实际项目中可能需要更复杂的NLP工具
        sentences = re.split(r'(?<=[.!?])\s+', text)
        return [s.strip() for s in sentences if s.strip()]
    
    def create_chunks(self, text: str, metadata: Dict[str, Any]) -> List[DocumentChunk]:
        """创建文档块"""
        cleaned_text = self.clean_text(text)
        sentences = self.split_by_sentences(cleaned_text)
        
        chunks = []
        current_chunk = []
        current_length = 0
        
        for sentence in sentences:
            sentence_length = len(sentence)
            
            # 如果当前块加上新句子会超过大小,且当前块不为空
            if current_length + sentence_length > self.chunk_size and current_chunk:
                # 保存当前块
                chunk_text = ' '.join(current_chunk)
                chunk_id = f"{metadata.get('doc_id', 'unknown')}_{len(chunks)}"
                chunks.append(DocumentChunk(
                    content=chunk_text,
                    metadata=metadata.copy(),
                    chunk_id=chunk_id
                ))
                
                # 保留重叠部分开始新块
                overlap_sentences = current_chunk[-self.chunk_overlap:] if len(current_chunk) > self.chunk_overlap else current_chunk
                current_chunk = overlap_sentences + [sentence]
                current_length = sum(len(s) for s in current_chunk)
            else:
                current_chunk.append(sentence)
                current_length += sentence_length
        
        # 添加最后一个块
        if current_chunk:
            chunk_text = ' '.join(current_chunk)
            chunk_id = f"{metadata.get('doc_id', 'unknown')}_{len(chunks)}"
            chunks.append(DocumentChunk(
                content=chunk_text,
                metadata=metadata.copy(),
                chunk_id=chunk_id
            ))
        
        return chunks

# 使用示例
processor = DocumentProcessor(chunk_size=500, chunk_overlap=50)

# 模拟文档
sample_docs = [
    {
        "id": "doc_001",
        "title": "Weaviate向量数据库使用指南",
        "content": """Weaviate是一个开源的向量数据库,专为AI应用设计。它支持多种向量化模型,包括OpenAI、Cohere、HuggingFace等。Weaviate的核心特性包括:1. 混合搜索:结合向量搜索和关键词搜索;2. 生成式搜索:直接集成大模型生成能力;3. 多租户支持:为不同用户或应用隔离数据。在实际使用中,需要注意数据建模、索引优化和查询性能调优。""",
        "category": "技术文档",
        "source": "官方文档"
    },
    {
        "id": "doc_002", 
        "title": "RAG系统架构设计",
        "content": """RAG(检索增强生成)系统通常包含四个主要组件:1. 文档加载器:从各种来源加载文档;2. 文本分割器:将长文档分割为适合向量化的块;3. 向量数据库:存储和检索文档向量;4. 大语言模型:基于检索到的上下文生成回答。关键设计考虑包括:块大小选择、重叠策略、检索策略和上下文窗口管理。""",
        "category": "架构设计",
        "source": "技术博客"
    }
]

# 处理文档
all_chunks = []
for doc in sample_docs:
    chunks = processor.create_chunks(
        doc["content"],
        {
            "doc_id": doc["id"],
            "title": doc["title"],
            "category": doc["category"],
            "source": doc["source"]
        }
    )
    all_chunks.extend(chunks)

print(f"总共生成 {len(all_chunks)} 个文档块")
for i, chunk in enumerate(all_chunks[:2]):  # 显示前两个块
    print(f"\n块 {i+1}:")
    print(f"内容: {chunk.content[:100]}...")
    print(f"元数据: {chunk.metadata}")

文档分割是RAG系统的关键步骤。块太小会丢失上下文信息,块太大会降低检索精度。我通常根据内容类型调整:技术文档用300-500字,对话记录用100-200字,长篇文章可能需要分层分割。

5.2 向量化存储与检索

处理好的文档块需要向量化并存储到Weaviate:

class RAGSystem:
    """RAG系统核心类"""
    
    def __init__(self, weaviate_client, collection_name="rag_documents"):
        self.client = weaviate_client
        self.collection_name = collection_name
        self.collection = None
        
    def setup_collection(self):
        """设置RAG专用集合"""
        # 检查集合是否存在
        if self.collection_name in self.client.collections.list_all():
            self.collection = self.client.collections.get(self.collection_name)
            print(f"使用现有集合: {self.collection_name}")
            return
        
        # 创建新集合
        self.collection = self.client.collections.create(
            name=self.collection_name,
            description="RAG系统文档存储",
            vectorizer_config=weaviate.classes.config.Configure.Vectorizer.text2vec_openai(),
            generative_config=weaviate.classes.config.Configure.Generative.openai(),
            properties=[
                weaviate.classes.config.Property(
                    name="content",
                    data_type=weaviate.classes.config.DataType.TEXT,
                    description="文档内容",
                    vectorize_property_name=True,
                    index_searchable=True,
                ),
                weaviate.classes.config.Property(
                    name="title",
                    data_type=weaviate.classes.config.DataType.TEXT,
                    description="文档标题",
                    vectorize_property_name=True,
                    index_searchable=True,
                ),
                weaviate.classes.config.Property(
                    name="doc_id",
                    data_type=weaviate.classes.config.DataType.TEXT,
                    description="文档ID",
                    vectorize_property_name=False,
                    index_filterable=True,
                ),
                weaviate.classes.config.Property(
                    name="category",
                    data_type=weaviate.classes.config.DataType.TEXT,
                    description="文档分类",
                    vectorize_property_name=False,
                    index_filterable=True,
                ),
                weaviate.classes.config.Property(
                    name="source",
                    data_type=weaviate.classes.config.DataType.TEXT,
                    description="文档来源",
                    vectorize_property_name=False,
                    index_filterable=True,
                ),
                weaviate.classes.config.Property(
                    name="chunk_index",
                    data_type=weaviate.classes.config.DataType.INT,
                    description="块索引",
                    vectorize_property_name=False,
                    index_filterable=True,
                ),
            ]
        )
        print(f"创建新集合: {self.collection_name}")
    
    def store_documents(self, document_chunks: List[DocumentChunk], batch_size=100):
        """存储文档块到Weaviate"""
        if not self.collection:
            self.setup_collection()
        
        total_chunks = len(document_chunks)
        print(f"开始存储 {total_chunks} 个文档块...")
        
        with self.collection.batch.dynamic() as batch:
            for i, chunk in enumerate(document_chunks):
                # 准备对象属性
                properties = {
                    "content": chunk.content,
                    "title": chunk.metadata.get("title", ""),
                    "doc_id": chunk.metadata.get("doc_id", ""),
                    "category": chunk.metadata.get("category", ""),
                    "source": chunk.metadata.get("source", ""),
                    "chunk_index": chunk.metadata.get("chunk_index", i),
                }
                
                # 添加对象到批次
                batch.add_object(
                    properties=properties,
                    # 如果有预计算的向量,可以在这里传入
                    # vector=chunk.vector
                )
                
                # 显示进度
                if (i + 1) % batch_size == 0 or (i + 1) == total_chunks:
                    print(f"已处理 {i + 1}/{total_chunks} 个文档块")
        
        print("文档存储完成!")
    
    def retrieve_relevant_chunks(self, query: str, limit=5, filters=None):
        """检索相关文档块"""
        if not self.collection:
            self.setup_collection()
        
        # 构建查询
        query_builder = self.collection.query.hybrid(
            query=query,
            alpha=0.7,  # 偏向语义搜索
            limit=limit,
            return_metadata=weaviate.classes.query.MetadataQuery(
                distance=True,
                score=True
            )
        )
        
        # 应用过滤条件
        if filters:
            query_builder = query_builder.with_where(filters)
        
        # 执行查询
        response = query_builder.do()
        
        # 提取结果
        results = []
        for obj in response.objects:
            result = {
                "content": obj.properties["content"],
                "title": obj.properties["title"],
                "doc_id": obj.properties["doc_id"],
                "category": obj.properties["category"],
                "source": obj.properties["source"],
                "distance": obj.metadata.distance if obj.metadata else None,
                "score": obj.metadata.score if obj.metadata else None,
            }
            results.append(result)
        
        return results

# 初始化RAG系统
rag_system = RAGSystem(client)

# 存储文档块
rag_system.store_documents(all_chunks)

# 测试检索
test_query = "Weaviate有什么核心特性?"
relevant_chunks = rag_system.retrieve_relevant_chunks(test_query, limit=3)

print(f"\n查询: '{test_query}'")
print("检索到的相关文档块:")
for i, chunk in enumerate(relevant_chunks):
    print(f"\n[{i+1}] {chunk['title']} (距离: {chunk['distance']:.4f})")
    print(f"来源: {chunk['source']}")
    print(f"内容: {chunk['content'][:150]}...")

这里我设置了alpha=0.7,因为RAG场景中语义理解比关键词匹配更重要。实际应用中,你可能需要根据查询类型动态调整这个参数。

5.3 集成大模型生成回答

检索到相关文档后,我们需要将它们作为上下文提供给大模型生成回答:

import openai
from typing import List, Dict, Any

class AnswerGenerator:
    """回答生成器"""
    
    def __init__(self, model="gpt-3.5-turbo", temperature=0.7):
        self.model = model
        self.temperature = temperature
        self.client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    
    def format_context(self, chunks: List[Dict[str, Any]]) -> str:
        """格式化检索到的上下文"""
        context_parts = []
        for i, chunk in enumerate(chunks, 1):
            context_parts.append(f"[文档{i}] {chunk['title']}")
            context_parts.append(f"内容: {chunk['content']}")
            context_parts.append(f"来源: {chunk['source']}")
            context_parts.append("")  # 空行分隔
        
        return "\n".join(context_parts)
    
    def generate_answer(self, query: str, context_chunks: List[Dict[str, Any]]) -> Dict[str, Any]:
        """生成回答"""
        # 格式化上下文
        context = self.format_context(context_chunks)
        
        # 构建提示词
        system_prompt = """你是一个专业的AI助手,基于提供的上下文信息回答问题。
        请遵循以下规则:
        1. 只基于提供的上下文信息回答,不要添加外部知识
        2. 如果上下文信息不足以回答问题,请如实说明
        3. 回答要简洁、准确、有帮助
        4. 引用相关的文档来源
        
        上下文信息:
        {context}
        """
        
        user_prompt = f"问题:{query}\n\n请基于上面的上下文信息回答这个问题。"
        
        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": system_prompt.format(context=context)},
                    {"role": "user", "content": user_prompt}
                ],
                temperature=self.temperature,
                max_tokens=1000
            )
            
            answer = response.choices[0].message.content
            
            # 提取引用的文档
            cited_docs = []
            for chunk in context_chunks:
                if any(ref in answer for ref in [chunk['title'], chunk['doc_id']]):
                    cited_docs.append({
                        "title": chunk['title'],
                        "source": chunk['source'],
                        "relevance_score": chunk.get('score', 0)
                    })
            
            return {
                "answer": answer,
                "cited_documents": cited_docs,
                "context_chunks_used": len(context_chunks),
                "model": self.model
            }
            
        except Exception as e:
            return {
                "error": str(e),
                "answer": "抱歉,生成回答时出现错误。",
                "cited_documents": []
            }

# 完整的RAG流程
def rag_pipeline(query: str, limit_context=3):
    """完整的RAG流程"""
    print(f"\n{'='*60}")
    print(f"RAG流程开始 - 查询: '{query}'")
    print('='*60)
    
    # 1. 检索相关文档
    print("\n1. 检索相关文档...")
    relevant_chunks = rag_system.retrieve_relevant_chunks(query, limit=limit_context)
    print(f"   检索到 {len(relevant_chunks)} 个相关文档块")
    
    # 2. 生成回答
    print("\n2. 生成回答...")
    generator = AnswerGenerator()
    result = generator.generate_answer(query, relevant_chunks)
    
    # 3. 输出结果
    print("\n3. 最终回答:")
    print("-" * 40)
    print(result["answer"])
    print("-" * 40)
    
    if result.get("cited_documents"):
        print("\n引用的文档:")
        for doc in result["cited_documents"]:
            print(f"  • {doc['title']} ({doc['source']})")
    
    if result.get("error"):
        print(f"\n错误: {result['error']}")
    
    return result

# 测试RAG流程
test_queries = [
    "Weaviate支持哪些搜索方式?",
    "RAG系统包含哪些组件?",
    "如何优化向量数据库的性能?"
]

for query in test_queries:
    result = rag_pipeline(query)
    print("\n" + "="*60 + "\n")

这个RAG系统有几个关键设计点:第一,提示词工程很重要,要明确告诉模型只基于提供的上下文回答;第二,要记录引用的文档,方便用户追溯来源;第三,要有错误处理机制,避免整个流程因为单个环节失败而崩溃。

5.4 高级RAG技巧与优化

基础RAG搭建好后,还可以进一步优化:

class AdvancedRAGSystem(RAGSystem):
    """增强版RAG系统"""
    
    def __init__(self, weaviate_client, collection_name="rag_documents"):
        super().__init__(weaviate_client, collection_name)
        self.query_expander = QueryExpander()
        self.reranker = Reranker()
    
    def expand_query(self, original_query: str) -> List[str]:
        """查询扩展,生成多个相关查询"""
        # 简单的同义词扩展
        expansion_rules = {
            "特性": ["特点", "功能", "特性", "能力"],
            "优点": ["优势", "好处", "优点", "强项"],
            "缺点": ["不足", "局限", "缺点", "弱点"],
            "如何": ["怎样", "怎么", "如何", "方法"],
            "为什么": ["原因", "为何", "为什么", "缘由"],
        }
        
        expanded_queries = [original_query]
        for word, synonyms in expansion_rules.items():
            if word in original_query:
                for synonym in synonyms:
                    if synonym != word:
                        expanded_queries.append(original_query.replace(word, synonym))
        
        return expanded_queries[:3]  # 最多扩展2个
    
    def multi_query_retrieval(self, query: str, limit_per_query=3) -> List[Dict[str, Any]]:
        """多查询检索,提高召回率"""
        expanded_queries = self.expand_query(query)
        print(f"扩展查询: {expanded_queries}")
        
        all_results = []
        for expanded_query in expanded_queries:
            chunks = super().retrieve_relevant_chunks(expanded_query, limit=limit_per_query)
            all_results.extend(chunks)
        
        # 去重
        seen_contents = set()
        unique_results = []
        for result in all_results:
            content_hash = hash(result["content"][:100])  # 用前100字符作为去重依据
            if content_hash not in seen_contents:
                seen_contents.add(content_hash)
                unique_results.append(result)
        
        return unique_results
    
    def rerank_results(self, query: str, chunks: List[Dict[str, Any]], top_k=5) -> List[Dict[str, Any]]:
        """对检索结果重新排序"""
        if not chunks:
            return []
        
        # 简单的基于距离和长度的重排序
        # 实际项目中可以使用更复杂的重排序模型
        for chunk in chunks:
            # 计算综合分数:距离越近分数越高,长度适中分数高
            distance_score = 1 - min(chunk.get("distance", 1), 1)  # 归一化
            length = len(chunk["content"])
            length_score = 1 - abs(length - 300) / 500  # 理想长度300字
            
            chunk["rerank_score"] = 0.7 * distance_score + 0.3 * length_score
        
        # 按重排序分数排序
        sorted_chunks = sorted(chunks, key=lambda x: x["rerank_score"], reverse=True)
        
        return sorted_chunks[:top_k]
    
    def advanced_rag_pipeline(self, query: str) -> Dict[str, Any]:
        """增强版RAG流程"""
        print(f"\n🔍 增强RAG流程 - 查询: '{query}'")
        print("=" * 60)
        
        # 1. 查询扩展和多查询检索
        print("\n1. 查询扩展与检索...")
        all_chunks = self.multi_query_retrieval(query)
        print(f"   初始检索到 {len(all_chunks)} 个文档块")
        
        # 2. 重排序
        print("\n2. 结果重排序...")
        reranked_chunks = self.rerank_results(query, all_chunks, top_k=5)
        print(f"   重排序后保留 {len(reranked_chunks)} 个文档块")
        
        # 3. 生成回答
        print("\n3. 生成回答...")
        generator = AnswerGenerator()
        result = generator.generate_answer(query, reranked_chunks)
        
        # 4. 添加检索质量评估
        result["retrieval_metrics"] = {
            "original_query": query,
            "expanded_queries": self.expand_query(query),
            "initial_chunks_count": len(all_chunks),
            "final_chunks_count": len(reranked_chunks),
            "average_distance": sum(c.get("distance", 1) for c in reranked_chunks) / len(reranked_chunks) if reranked_chunks else 0,
        }
        
        return result

# 使用增强版RAG
advanced_rag = AdvancedRAGSystem(client)

# 测试复杂查询
complex_queries = [
    "向量数据库在AI应用中的作用和优势",
    "对比Weaviate和其他向量数据库的差异",
]

for query in complex_queries:
    result = advanced_rag.advanced_rag_pipeline(query)
    print(f"\n回答: {result['answer'][:200]}...")
    print(f"检索指标: {result['retrieval_metrics']}")
    print("\n" + "="*60 + "\n")

增强版RAG系统加入了几个重要优化:查询扩展提高了召回率,重排序提高了精度,检索质量评估帮助我们监控系统表现。在实际项目中,我还会加入更多优化,比如查询分类(区分事实型、解释型、比较型问题)、上下文窗口优化(动态调整块大小)、以及反馈学习(根据用户反馈调整检索策略)。

6. 性能优化与生产部署建议

当你的RAG系统从原型走向生产时,性能优化就变得至关重要。我经历过从几百条数据到几百万条数据的 scaling,总结了一些实用的优化经验。

6.1 索引策略优化

Weaviate支持多种索引类型,选择正确的索引对性能影响巨大:

def optimize_indexing(collection_name="optimized_docs"):
    """优化索引配置"""
    
    # 删除现有集合(如果存在)
    if collection_name in client.collections.list_all():
        client.collections.delete(collection_name)
        print(f"已删除旧集合: {collection_name}")
    
    # 创建优化后的集合
    optimized_collection = client.collections.create(
        name=collection_name,
        description="优化索引配置的集合",
        vectorizer_config=weaviate.classes.config.Configure.Vectorizer.text2vec_openai(),
        
        # 向量索引配置 - 这是性能关键
        vector_index_config=weaviate.classes.config.Configure.VectorIndex.hnsw(
            # HNSW参数调优
            ef_construction=128,  # 构建时的邻居数,影响索引质量和构建速度
            max_connections=16,   # 每个节点的最大连接数,影响搜索速度和内存
            ef=64,                # 搜索时的动态候选列表大小
            dynamic_ef_min=32,    # 动态ef的最小值
            dynamic_ef_max=128,   # 动态ef的最大值
            dynamic_ef_factor=8,  # 动态ef的因子
        ),
        
        # 倒排索引配置 - 影响过滤性能
        inverted_index_config=weaviate.classes.config.Configure.inverted_index(
            bm25_b=0.75,          # BM25的b参数,控制文档长度归一化
            bm25_k1=1.2,          # BM25的k1参数,控制词频饱和度
            cleanup_interval_seconds=300,  # 清理间隔
        ),
        
        # 分片配置 - 影响水平扩展
        sharding_config=weaviate.classes.config.Configure.sharding(
            virtual_per_physical=128,  # 虚拟分片数
            actual_count=1,            # 实际分片数(单节点)
            desired_count=1,            # 期望分片数
            function="murmur3",         # 分片函数
        ),
        
        # 副本配置 - 影响可用性和读取性能
        replication_config=weaviate.classes.config.Configure.replication(
            factor=1,  # 副本因子,生产环境建议>=2
        ),
        
        properties=[
            weaviate.classes.config.Property(
                name="content",
                data_type=weaviate.classes.config.DataType.TEXT,
                index_filterable=True,
                index_searchable=True,
                # 文本索引优化
                tokenization=weaviate.classes.config.Tokenization.WORD,  # 分词方式
                index_inverted=True,  # 启用倒排索引
                index_nullstate=True,  # 索引空值状态
            ),
            # ... 其他属性配置
        ]
    )
    
    print(f"创建优化集合: {collection_name}")
    print("索引配置:")
    print(f"  - HNSW: ef_construction={128}, max_connections={16}")
    print(f"  - BM25: b={0.75}, k1={1.2}")
    print(f"  - 分片: virtual_per_physical={128}")
    
    return optimized_collection

# 测试不同数据量下的性能
def benchmark_performance(collection, data_sizes=[100, 1000, 10000]):
    """性能基准测试"""
    import time
    
    results = {}
    
    for size in data_sizes:
        print(f"\n测试数据量: {size} 条")
        
        # 准备测试数据
        test_data = []
        for i in range(size):
            test_data.append({
                "content": f"测试文档内容 {i} " * 10,  # 模拟真实文档长度
                "title": f"测试标题 {i}",
                "category": "测试" if i % 2 == 0 else "生产",
                "view_count": i * 100,
            })
        
        # 测试插入性能
        start_time = time.time()
        with collection.batch.dynamic() as batch:
            for i, data in enumerate(test_data):
                batch.add_object(properties=data)
                if i % 1000 == 0 and i > 0:
                    print(f"  已插入 {i} 条")
        
        insert_time = time.time() - start_time
        print(f"  插入 {size} 条数据耗时: {insert_time:.2f}秒")
        
        # 等待索引构建
        time.sleep(2)
        
        # 测试搜索性能
        search_times = []
        test_queries = ["测试文档", "生产数据", "性能基准"]
        
        for query in test_queries:
            start_time = time.time()
            response = collection.query.hybrid(
                query=query,
                limit=10,
                return_metadata=weaviate.classes.query.MetadataQuery(distance=True)
            )
            search_time = time.time() - start_time
            search_times.append(search_time)
        
        avg_search_time = sum(search_times) / len(search_times)
        print(f"  平均搜索耗时: {avg_search_time*1000:.2f}毫秒")
        
        results[size] = {
            "insert_time": insert_time,
            "avg_search_time": avg_search_time,
            "throughput": size / insert_time if insert_time > 0 else 0
        }
    
    return results

# 运行性能测试
optimized_collection = optimize_indexing()
performance_results = benchmark_performance(optimized_collection, [100, 1000, 5000])

print("\n性能测试结果汇总:")
print("数据量 | 插入时间(s) | 搜索时间(ms) | 吞吐量(条/s)")
print("-" * 50)
for size, metrics in performance_results.items():
    print(f"{size:6d} | {metrics['insert_time']:10.2f} | {metrics['avg_search_time']*1000:12.2f} | {metrics['throughput']:10.2f}")

HNSW参数需要根据数据规模和查询模式调整:数据量大、查询要求高精度时,增加ef_construction和max_connections;对查询延迟敏感时,适当降低这些值。BM25参数主要影响关键词搜索的相关性评分,一般用默认值即可。

6.2 查询优化技巧

除了索引优化,查询本身的优化也很重要:

class QueryOptimizer:
    """查询优化器"""
    
    @staticmethod
    def optimize_hybrid_search(query, filters=None, auto_alpha=True):
        """优化混合搜索参数"""
        
        # 根据查询长度自动调整alpha
        if auto_alpha:
            query_length = len(query.split())
            if query_length <= 2:
                # 短查询,更依赖关键词匹配
                alpha = 0.3
                search_type = "关键词主导"
            elif query_length <= 5:
                # 中等长度查询,平衡两者
                alpha = 0.5
                search_type = "平衡搜索"
            else:
                # 长查询,更依赖语义理解
                alpha = 0.7
                search_type = "语义主导"
        else:
            alpha = 0.5
            search_type = "固定参数"
        
        # 根据查询复杂度调整limit
        if filters and len(filters) > 2:
            # 复杂过滤需要更多候选结果
            limit = 20
        else:
            limit = 10
        
        # 构建优化后的查询配置
        optimized_config = {
            "alpha": alpha,
            "limit": limit,
            "search_type": search_type,
            "query_properties": ["content", "title", "tags"],
            "auto_cutoff": 0.1,  # 自动截断低分结果
        }
        
        print(f"查询优化建议:")
        print(f"  - 搜索类型: {search_type}")
        print(f"  - Alpha值: {alpha}")
        print(f"  - 返回数量: {limit}")
        
        return optimized_config
    
    @staticmethod
    def analyze_query_pattern(queries):
        """分析查询模式"""
        from collections import Counter
        import re
        
        patterns = {
            "factual": 0,  # 事实型查询
            "comparative": 0,  # 比较型查询
            "procedural": 0,  # 流程型查询
            "exploratory": 0,  # 探索型查询
        }
        
        factual_keywords = ["是什么", "什么是", "定义", "解释"]
        comparative_keywords = ["对比", "比较", "区别", "差异"]
        procedural_keywords = ["如何", "怎样", "步骤", "方法"]
        exploratory_keywords = ["为什么", "原因", "影响", "趋势"]
        
        for query in queries:
            query_lower = query.lower()
            
            if any(keyword in query_lower for keyword in factual_keywords):
                patterns["factual"] += 1
            elif any(keyword in query_lower for keyword in comparative_keywords):
                patterns["comparative"] += 1
            elif any(keyword in query_lower for keyword in procedural_keywords):
                patterns["procedural"] += 1
            elif any(keyword in query_lower for keyword in exploratory_keywords):
                patterns["exploratory"] += 1
        
        total = sum(patterns.values())
        if total > 0:
            patterns = {k: v/total for k, v in patterns.items()}
        
        return patterns

# 使用查询优化
optimizer = QueryOptimizer()

# 分析历史查询模式
historical_queries = [
    "什么是向量数据库",
    "Weaviate和Pinecone有什么区别",
    "如何安装Weaviate",
    "为什么选择Weaviate而不是传统数据库",
    "向量搜索的原理",
    "如何优化Weaviate性能",
]

patterns = optimizer.analyze_query_pattern(historical_queries)
print("查询模式分析:")
for pattern, percentage in patterns.items():
    print(f"  {pattern}: {percentage:.1%}")

# 优化单个查询
test_query = "如何配置Weaviate的HNSW参数以获得最佳性能"
optimized_config = optimizer.optimize_hybrid_search(test_query, auto_alpha=True)

# 使用优化配置执行查询
collection = client.collections.get("optimized_docs")
response = collection.query.hybrid(
    query=test_query,
    alpha=optimized_config["alpha"],
    limit=optimized_config["limit"],
    query_properties=optimized_config["query_properties"],
    auto_limit=optimized_config["auto_cutoff"],
    return_metadata=weaviate.classes.query.MetadataQuery(
        score=True,
        explain_score=True
    )
)

print(f"\n优化后查询结果数量: {len(response.objects)}")

6.3 生产环境部署建议

基于我在多个生产项目的经验,这里分享一些部署建议:

  1. 硬件配置:

    • CPU:至少4核,推荐8核以上
    • 内存:数据量×(向量维度×4字节 + 元数据开销),建议预留30%缓冲
    • 存储:SSD必备,IOPS越高越好
    • 网络:千兆网卡,低延迟网络
  2. 集群部署:

    # docker-compose.cluster.yml
    version: '3.4'
    services:
      weaviate-node1:
        image: cr.weaviate.io/semitechnologies/weaviate:1.33.1
        command:
          - --host
          - 0.0.0.0
          - --port
          - '8080'
          - --scheme
          - http
        environment:
          CLUSTER_HOSTNAME: 'node1'
          CLUSTER_JOIN: 'node2,node3'
          RAFT_BOOTSTRAP_EXPECT: 3
          # ... 其他配置
        
      weaviate-node2:
        image: cr.weaviate.io/semitechnologies/weaviate:1.33.1
        command:
          - --host
          - 0.0.0.0
          - --port
          - '8081'
          - --scheme
          - http
        environment:
          CLUSTER_HOSTNAME: 'node2'
          CLUSTER_JOIN: 'node1,node3'
          RAFT_BOOTSTRAP_EXPECT: 3
        
      weaviate-node3:
        # 类似配置
    
  3. 监控告警:

    class WeaviateMonitor:
        """Weaviate监控器"""
        
        def __init__(self, client, alert_thresholds=None):
            self.client = client
            self.thresholds = alert_thresholds or {
                'query_latency_ms': 100,  # 查询延迟阈值
                'error_rate': 0.01,       # 错误率阈值
                'memory_usage_percent': 80, # 内存使用阈值
            }
        
        def collect_metrics(self):
            """收集监控指标"""
            metrics = {}
            
            # 获取集群状态
            cluster_status = self.client.cluster.get_nodes_status()
            metrics['node_count'] = len(cluster_status.nodes)
            metrics['healthy_nodes'] = sum(1 for n in cluster_status.nodes if n.status == 'HEALTHY')
            
            # 获取性能指标(需要启用监控)
            # metrics['queries_per_second'] = self.get_qps()
            # metrics['average_latency'] = self.get_avg_latency()
            
            return metrics
        
        def check_alerts(self, metrics):
            """检查告警条件"""
            alerts = []
            
            # 节点健康检查
            if metrics.get('healthy_nodes', 0) < metrics.get('node_count', 1):
                alerts.append({
                    'level': 'ERROR',
                    'message': f"有节点不健康: {metrics['healthy_nodes']}/{metrics['node_count']}",
                    'timestamp': datetime.now().isoformat()
                })
            
            # 内存检查(示例)
            if metrics.get('memory_usage_percent', 0) > self.thresholds['memory_usage_percent']:
                alerts.append({
                    'level': 'WARNING',
                    'message': f"内存使用率过高: {metrics['memory_usage_percent']}%",
                    'timestamp': datetime.now().isoformat()
                })
            
            return alerts
        
        def generate_report(self, metrics, alerts):
            """生成监控报告"""
            report = {
                'timestamp': datetime.now().isoformat(),
                'metrics': metrics,
                'alerts': alerts,
                'summary': {
                    'status': 'HEALTHY' if not alerts else 'UNHEALTHY',
                    'alert_count': len(alerts),
                }
            }
            return report
    
  4. 备份策略:

    # 定期备份脚本
    #!/bin/bash
    BACKUP_DIR="/backups/weaviate"
    DATE=$(date +%Y%m%d_%H%M%S)
    
    # 创建备份
    docker exec weaviate-node1 \
      curl -X POST "http://localhost:8080/v1/backups/filesystem" \
      -H "Content-Type: application/json" \
      -d "{
        \"id\": \"backup_${DATE}\",
        \"include\": \"Article,Document\",
        \"backend\": \"filesystem\"
      }"
    
    # 检查备份状态
    sleep 30
    docker exec weaviate-node1 \
      curl "http://localhost:8080/v1/backups/filesystem/backup_${DATE}"
    
    # 同步到远程存储
    aws s3 sync "${BACKUP_DIR}" "s3://my-weaviate-backups/${DATE}/"
    
  5. 安全配置:

    # 生产环境安全配置
    environment:
      AUTHENTICATION_APIKEY_ENABLED: 'true'
      AUTHENTICATION_APIKEY_ALLOWED_KEYS: '${WEAVIATE_API_KEY}'
      AUTHORIZATION_ADMINLIST_ENABLED: 'true'
      AUTHORIZATION_ADMINLIST_USERS: 'admin@company.com'
      AUTHORIZATION_ADMINLIST_READONLY_USERS: 'readonly@company.com'
      ENABLE_API_LOGGING: 'true'
      LOG_LEVEL: 'info'
      REQUEST_LOG_LEVEL: 'info'
      # 限制资源使用
      MAX_IMPORT_BATCH_SIZE: '100'
      MAX_IMPORT_CONCURRENT_REQUESTS: '2'
      QUERY_MAXIMUM_RESULTS: '1000'
      QUERY_DEFAULTS_LIMIT: '100'
    

7. 常见问题与故障排除

在实际使用Weaviate的过程中,你可能会遇到各种问题。这里我整理了一些常见问题及其解决方案,都是我在项目中真实遇到过的。

7.1 连接与配置问题

问题1:连接Weaviate时超时或拒绝连接

def test_connection(client):
    """测试Weaviate连接"""
    try:
        # 方法1:使用is_ready()
        is_ready = client.is_ready()
        print(f"is_ready(): {is_ready}")
        
        # 方法2:获取元数据
        meta = client.get_meta()
        print(f"版本: {meta.version}")
        print(f)
【向量数据库Weaviate】 和Elasticsearch的区别 Weaviate语义搜索优先,ElasticSearch关键词搜索优先 阅读详情

相关推荐

Weaviate示例库实战指南:从零构建企业级RAG应用

向量数据库作为AI时代处理非结构化数据的核心基础设施,通过将文本、图像等数据转化为高维向量,并利用相似性计算实现语义级检索。其技术原理基于嵌入模型(如text-embedding-ada-002)将数据映射到向量空间,再通过近似最近邻搜索算法快速定位相似项。这项技术的核心价值在于为语义搜索、个性化推荐及RAG(检索增强生成)等场景提供了高效的数据检索能力。在实际应用中,开发者常面临模型选型、数据分块优化和混合搜索调参等工程挑战。本文以Weaviate官方示例库为蓝本,深入解析如何结合LangChain框架,

weixin_28725959的博客 597

开源向量搜索引擎数据库Weaviate

Weaviate 和 Milvus 各有优势,适用于不同的应用场景和需求。Weaviate 更适合需要复杂查询和语义理解的场景,尤其是在知识图谱和推荐系统中表现优异。而 Milvus 则更适合大规模数据处理和高性能要求的应用,尤其是在图像和视频分析领域。开发者应根据具体的应用场景、数据规模和性能需求选择合适的向量数据库。Weaviate 和 Qdrant 都是优秀的开源向量数据库,但它们在核心特性、性能、扩展性、使用场景和社区支持等方面存在差异。

Made In SQL 1071

Word公式一键转MathType保姆级教程(附omml2mml.xsl报错终极解决方案)

本文提供Word公式一键转MathType的保姆级教程,重点解决常见的omml2mml.xsl报错问题。通过详细分析报错原因、官方解决方案实操步骤及转换后格式优化技巧,帮助用户高效完成公式转换,适用于科研论文和商业文档编辑。

weixin_30082367的博客 576

向量数据库Weaviate使用教程(安装+使用)

向量数据库Weaviate使用教程(安装+使用)

weixin_45683241的博客 2万+

华为/H3C/锐捷交换机配置命令对比表:一张图搞定VLAN划分与端口设置

本文详细对比了华为、H3C、锐捷三大品牌交换机在VLAN划分与端口设置中的配置命令差异,提供从基础配置到高级功能的横向对比表,帮助网络工程师快速掌握多品牌设备混用环境下的配置技巧,提升工作效率。

rust6ferris的博客 702

《LabVIEW ZYNQ实战指南》第6章>>案例解析:基于USB WiFi模块的ZYNQ无线通信部署与Linux RT开发

本文详细解析了如何为ZYNQ开发板部署USB WiFi模块,实现无线通信。通过LabVIEW Linux RT环境,利用封装好的驱动VI,开发者可轻松配置ZYNQ连接无线网络,摆脱网线束缚,实现程序无线部署与远程调试,为工业物联网应用奠定基础。

app77的博客 757

【Spring AI 】向量数据库Weaviate部署

Weaviate 部署文档摘要 本文档提供 Weaviate v1.24.0 在 Linux(Ubuntu/CentOS)、macOS(Intel/Apple Silicon)和 Windows 10/11 上的部署指南。推荐使用 Docker 部署方案,详细说明了各系统 Docker 环境安装步骤,并提供了标准的 docker-compose.yml 配置文件模板。文档包含完整的服务启动流程、验证方法以及注意事项,特别针对国内 Docker 镜像拉取问题提供了解决方案建议

weixin_44338470的博客 1518

生成式引擎优化(GEO)- 搜索引擎优化

生成式引擎优化(GEO)是针对AI内容生成平台(如ChatGPT)的新型优化策略,旨在提升品牌内容在AI生成答案中的引用率,与传统SEO存在显著差异。GEO通过优化内容权威性、结构化和语义关联,适应AI的RAG技术架构,采用3C原则(可爬性、网络共识、反馈校正)提升内容可见性。其核心区别在于目标(引用率vs排名)、技术(语义优化vs关键词)及算法透明度(封闭vs开放)。适用场景包括商业决策、行业权威建设及公共知识服务,帮助品牌在AI时代占据信息主导权。

解锁AI流量新红利!🚀 GEO优化(生成引擎优化)助您掌控AI搜索,让AI成为您的品牌最佳代言人! 1408

weaviate入门

Weaviate是一款由德国SeMITechnologies开发的开源向量搜索引擎数据库,结合了向量搜索和图数据库技术,专为AI应用提供高效的数据存储和检索。其核心功能包括高效的向量索引和近似最近邻(ANN)搜索、图数据结构、机器学习模块支持、模块化设计以及基于GraphQL的强大查询语言。Weaviate支持多种部署方式,如Weaviate云、Docker、Kubernetes和嵌入式部署,适用于不同场景。使用流程包括环境准备、创建集合、插入数据和执行向量搜索。Weaviate的优势在于低延迟、灵活扩展、

Made In SQL 1457

制作 img系统镜像的详细方法

      I.MX6开发板目前支持从TF卡和eMMC启动,启动时,由于各个不同的启动文件对路径有不同的要求,例如uboot文件要求位于启动设备的某个块,dtb文件要求在FAT分区上,文件系统要求在Linux分区上,基于此,我们目前采用将映像制作成img文件的方式,这样可以更简单完成对启动卡的制作。 关于如何制作img,方法如下:方法一  Windows下面利用Win32工具1.   准备我司提供...

armkits的博客 4万+

SECS/GSM 测试工具 SecsExpress 的配置与实战应用

本文详细介绍了半导体设备通讯测试工具SecsExpress的配置与实战应用。作为专业的SECS/GSM协议调试工具,它能模拟Host与设备端进行双向测试,帮助工程师快速部署、验证通讯链路,并高效排查与RMS系统或真实设备间的联调问题,是提升半导体工厂设备集成与维护效率的利器。

yhn456789的博客 302

深入探索Weaviate:构建高效AI应用的数据库解决方案

在当今数据驱动的世界中,高效地存储、检索和处理大规模数据成为了AI应用开发的关键挑战。Weaviate作为一个开源的向量搜索引擎,凭借其强大的功能和灵活的架构,正逐渐成为开发者构建智能AI应用的首选工具。本文将深入探讨Weaviate的核心概念、架构设计、索引机制以及其在实际应用中的优势。

neweastsun的专栏 1547

【Claude Code 源码解析教程】第4章:QueryEngine 查询引擎

本章深入解析 Claude Code 的核心引擎——QueryEngine,它是整个对话系统的"心脏",负责管理会话状态、消息处理流程和多轮对话支持。

rengang66的博客 270

Weaviate与Docker的完美结合:从零构建AI驱动的向量搜索服务

本文详细介绍了如何利用Docker容器化技术快速部署和配置Weaviate向量搜索引擎,构建AI驱动的语义搜索服务。从基础部署到高级模块集成,再到生产环境的最佳实践,帮助开发者高效实现非结构化数据的智能检索与推荐功能。

plum99的博客 172

【时时三省】tessy 单元测试 之 CTE(The Classification Tree Editor) 的使用

有图有文字详细介绍利用 CTE界面中的树 批量产生用例。

时时三省的博客 840

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

如何构建企业级智能检索系统:Weaviate向量数据库与AnythingLLM完整集成指南

在当今AI驱动的时代,构建高效的智能检索系统已成为企业数字化转型的关键。**Weaviate向量数据库**与**AnythingLLM**的完美结合,为您提供了一个强大、灵活且易于部署的企业级解决方案。本指南将详细介绍如何利用这两个开源工具构建功能全面的智能检索系统,让您能够轻松处理海量文档并进行精准语义搜索。 ## 为什么选择Weaviate作为AnythingLLM的向量存储后端? Wea

gitblog_00367的博客 973

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

向量数据库weaviate安装与入门

Weaviate是一个开源的向量搜索引擎,它允许用户存储数据对象和向量嵌入,并基于语义相似性搜索数据。Weaviate采用现代架构设计,特别适合处理非结构化数据和构建AI驱动的应用程序。

Made In SQL 1213

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

大模型最常使用的5大向量数据库:Chroma、Pinecone、Weaviate、Milvus和Faiss

随着人工智能和大数据技术的飞速发展,,正逐渐崭露头角。作为该领域的佼佼者,各具特色,分别在易用性、实时性、语义搜索、大规模数据处理和高效性方面表现出色。它们不仅推动了向量数据库技术的进步,更为各行各业的应用提供了强有力的支持。本文将从关键词、功能特性、应用系统、推荐指数4个维度来简要介绍5大最常使用的向量数据库。

2401_84033492的博客 5599

从零构建RAG系统:如何用Chroma、Milvus、Faiss和Weaviate搭建高效语义搜索引擎

本文详细介绍了如何从零构建RAG系统,利用Chroma、Milvus、Faiss和Weaviate等开源向量数据库搭建高效的语义搜索引擎。通过实战指南和性能对比,帮助开发者选择适合不同场景的解决方案,提升AI应用的检索效率和准确性。

dropout6artist的博客 605

RAG下的向量库用Weaviate还是用Postgres

摘要: Weaviate与PostgreSQL(搭配向量扩展)是向量检索的热门技术选项,但定位差异显著。PostgreSQL是关系型数据库,通过扩展支持向量检索,适合结构化业务数据与向量一体化存储(千万级以下)。Weaviate是原生向量数据库,擅长大规模向量检索与复杂混合查询(亿级向量仍低延迟)。选型关键: PostgreSQL适用场景:需事务、JOIN查询且向量规模较小(如企业轻量RAG系统)。 Weaviate适用场景:向量为核心、数据量大或需复杂混合检索(如全网文档搜索)。 混合架构:两者结合可兼顾

BREATH57的博客 977

【AI开发必备】Weaviate向量数据库让大模型秒懂人类语言!零代码小白也能部署的AI神器,附完整教程+实战案例!

Weaviate是一款开源的AI原生向量数据库,专为处理高维数据而设计,支持语义搜索、推荐系统和AI模型构建。其分布式架构可水平扩展,无单点故障,并提供混合搜索能力。文章通过详细代码示例展示了如何部署Weaviate、定义Schema、插入数据及实现语义搜索和检索增强生成(RAG)。相比其他向量数据库,Weaviate在开源、混合搜索和AI模型集成方面具有明显优势,为AI开发者提供了强大而灵活的数据管理解决方案。

weixin_58753619的博客 405

LangChain框架入门13:从0到1学习Weaviate向量数据库

本文介绍了向量数据库Weaviate的核心概念和实际应用。首先概述了向量数据库的特性,包括高维向量存储和相似性检索功能,区别于传统关系型数据库。重点讲解了Weaviate作为开源向量数据库的特点,涵盖其Go语言开发、多模态数据支持和多种部署方式。详细说明了Weaviate的核心对象(Collection和Object)及基本操作(连接、创建集合、增删改查等)。最后提供了Docker安装步骤和主要应用场景,包括语义搜索、智能推荐、医疗健康、图像检索和检索增强生成(RAG)等。通过http://172.16.2

ai12345678900008的博客 842

如何快速构建实时向量数据管道:Weaviate与Kafka/Flink集成指南

Weaviate作为开源向量数据库,不仅能高效存储和检索向量数据,还能与主流流处理平台无缝集成,构建端到端的实时数据处理系统。本文将详细介绍如何利用Weaviate的流处理能力,通过Kafka和Flink实现向量数据的实时摄入、处理与检索,帮助开发者轻松搭建企业级流数据应用。 ## 核心优势:Weaviate流处理集成的价值 Weaviate与流处理平台的集成打破了传统批处理的局限,带来三大核

gitblog_00355的博客 469

Weaviate: 开源向量数据库的强大功能与实践指南

Weaviate是一个开源的向量搜索引擎和数据库。它允许用户以类似于类属性的方式存储JSON文档,同时将机器学习生成的向量附加到这些文档上,以便在向量空间中表示它们。支持存储JSON文档和向量嵌入可扩展性强,能够处理数十亿级别的数据对象提供GraphQL API,方便数据访问支持多种媒体类型(文本、图像等)提供语义搜索、问答提取、分类等功能支持自定义模型(PyTorch/TensorFlow/Keras)使用Go语言从零开始构建,性能优异。

ppoojjj的博客 2746

Weaviate 介绍(向量数据库)

Weaviate 是一个开源的 AI 原生向量数据库,专为大规模向量搜索和 AI 应用设计。它支持多种搜索方式(纯向量、语义和混合搜索),提供 RAG、AI 代理等功能,并可通过 SDK(Python/Go/JS)或 API(GraphQL/REST)访问。安装方式灵活:Docker 适合本地开发,Kubernetes 适配生产环境,Embedded 模式可嵌入应用,Cloud 服务提供托管方案。Weaviate 简化 AI 开发流程,支持亿级数据扩展,整合 ML 模型,是构建 AI 应用的理想选择。

nbspzs的专栏 864

10分钟极速上手Weaviate:从0到1搭建智能向量搜索引擎

你是否还在为海量非结构化数据的高效检索而烦恼?面对文本、图像等复杂数据类型,传统数据库往往力不从心。本文将带你10分钟内搭建起Weaviate向量搜索引擎,让你轻松实现毫秒级相似性搜索,赋能智能推荐、语义分析等应用场景。读完本文,你将掌握环境部署、数据导入、向量搜索全流程,并了解如何通过可视化工具监控系统状态。 ## 什么是Weaviate? Weaviate是一款开源向量数据库(Vector...

gitblog_00374的博客 676
上一篇: Squoosh CLI实战:5分钟搞定批量图片压缩(附常用参数详解)
下一篇: 【Seed-Labs 2.0】Shellcode 实战:从零构建到64位架构的攻防演练
sql99
博客等级 码龄19年 168粉丝 1905原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值