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系统通常包含以下几个组件:
- 文档加载与处理:从各种来源加载文档,进行清洗和分割
- 向量化与存储:将文档块转换为向量并存入Weaviate
- 检索模块:根据用户查询检索相关文档
- 生成模块:将检索到的文档作为上下文,生成回答
- 评估与优化:监控系统效果并持续改进
我们先从文档处理开始。假设我们有一些技术文档需要处理:
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 生产环境部署建议
基于我在多个生产项目的经验,这里分享一些部署建议:
-
硬件配置:
- CPU:至少4核,推荐8核以上
- 内存:数据量×(向量维度×4字节 + 元数据开销),建议预留30%缓冲
- 存储:SSD必备,IOPS越高越好
- 网络:千兆网卡,低延迟网络
-
集群部署:
# 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: # 类似配置 -
监控告警:
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 -
备份策略:
# 定期备份脚本 #!/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}/" -
安全配置:
# 生产环境安全配置 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)
597



被折叠的 条评论
为什么被折叠?



