Вектордые базы данных для AI-агентов

Вектордые базы данных — это долгосрочная память AI-агентов. Без них LLM вынуждены полагаться только на то, что находится в их обучающих данных, которые часто устаревают, неполны или не соответствуют специфике задачи. С вектордыми базами данных агенты могут выполнять семантический поиск, запоминать предыдущие разговоры и получать доступ к специализированным знаниям через RAG (Retrieval-Augmented Generation).

Если ты разрабатываешь AI-агента, который делает что-то больше, чем просто отвечает на вопросы, рано или поздно понадобится вектордая база данных. В этой статье я разберу основные концепции, сравню главные решения и покажу полные примеры кода.

TL;DR — вектордые базы данных за 90 секунд

Что такое вектордая база данных?

Embeddings — основа всего

Прежде чем разбираться с вектордыми базами данных, нужно понять embeddings. Embedding — это числовое представление текста, массив сотен или тысяч чисел, которые захватывают “смысл” текста.

from openai import OpenAI
client = OpenAI()

# Text → вектор (1536 измерений для text-embedding-3-small)
response = client.embeddings.create(
    model="text-embedding-3-small",
    input="Python — язык программирования."
)

vector = response.data[0].embedding
print(f"Размерность: {len(vector)}")  # например, 1536
print(f"Первые 5 значений: {vector[:5]}")
# [0.012, -0.034, 0.056, 0.078, -0.091, ...]

Ключевой принцип: тексты с похожим смыслом имеют похожие векторы. “Python — язык программирования” и “Python — язык для скриптов” имеют векторы, которые близко расположены друг к другу. “Python — змея” имеет вектор, который находится намного дальше.

Поиск по схожести — как вектордые БД находят результаты

Вектордые базы данных ищут похожие векторы, используя метрики расстояния:

• Cosine Similarity: измеряет угол между векторами. Популярна для text embeddings. Значение 1 = идентичны, 0 = независимы.
• Euclidean Distance (L2): прямая линия между векторами. Меньшее расстояние = больше сходства.
• Dot Product: быстро, но менее информативно без нормализации.

# Косинусная схожесть вручную
import numpy as np

def cosine_similarity(v1, v2):
    return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))

sim = cosine_similarity(vector_a, vector_b)
# 0.95 = очень похожи, 0.50 = средне похожи, 0.10 = почти не похожи

Полный рабочий процесс

СОХРАНЕНИЕ:
Текст → модель embedding → вектор [0.12, -0.34, 0.56, ...] 
    → вектордая БД (с метаданными: источник, дата, категория)

ПОИСК:
Запрос "Что такое Python?" → модель embedding → вектор 
    → поиск по схожести в БД → Top-K самых похожих векторов 
    → вернуть связанные тексты

Зачем AI-агентам нужны вектордые базы данных?

1. Долгосрочная память

У LLM есть ограниченное контекстное окно (например, 128K токенов для GPT-4o). Разговоры, которые длиннее, нужно хранить внешне. Вектордые базы данных позволяют семантически найти релевантные предыдущие разговоры и загрузить их в контекст.

2. RAG — Retrieval-Augmented Generation

Вместо того чтобы полагаться на обучающие данные LLM, ты ищешь релевантные документы в вектордой базе и передаешь их в качестве контекста:

Вопрос пользователя → поиск в вектордой БД → топ 5 релевантных документов 
    → LLM-промпт: "Ответьте на вопрос, основываясь на этих документах: ..."

Это стандартный рабочий процесс для специализированных AI-агентов (например, поддержка клиентов, внутренние базы знаний, документация кода).

3. Семантический поиск

Обычный поиск требует точных ключевых слов. Вектордые базы находят семантическое сходство: “Как написать цикл?” найдет также “Реализация loop в Python”.

4. Масштабируемость

При миллионах документов поиск по ключевым словам медленный и неточный. Вектордые базы используют алгоритмы Approximate Nearest Neighbor (ANN), которые ищут даже в миллиардах векторов за миллисекунды.

Главные вектордые базы данных — подробно

Qdrant — высокопроизводительная система на Rust

Qdrant — вектордая база данных, написанная на Rust и оптимизированная для скорости и production-использования. Она поддерживает фильтрацию, метаданные payload и различные метрики расстояния.

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

# Подключение (локально или облако)
client = QdrantClient(host="localhost", port=6333)
# Или облако: QdrantClient(url="https://cluster-url", api_key="...")

# Создать collection (как таблица в SQL)
client.create_collection(
    "agent_memory",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
    # Опционально: оптимизация для production
    optimizers_config=OptimizersConfigDiff(
        indexing_threshold=0,  # Индексировать сразу
    )
)

# Вставить векторы с метаданными
client.upsert(
    "agent_memory",
    points=[
        PointStruct(
            id=1,
            vector=[0.12, -0.34, 0.56],  # На практике: 1536 измерений
            payload={
                "text": "Python — язык программирования.",
                "category": "programming",
                "source": "wikipedia",
                "date": "2026-07"
            }
        ),
        PointStruct(
            id=2,
            vector=[0.15, -0.31, 0.52],
            payload={
                "text": "Java — объектно-ориентированный язык.",
                "category": "programming",
                "source": "oracle-docs",
                "date": "2026-07"
            }
        )
    ]
)

# Семантический поиск с фильтром
results = client.search(
    "agent_memory",
    query_vector=[0.11, -0.32, 0.55],
    query_filter=Filter(
        must=[
            FieldCondition(key="category", match=MatchValue(value="programming"))
        ]
    ),
    limit=5
)

for result in results:
    print(f"Score: {result.score:.4f} - {result.payload['text']}")

Достоинства: очень быстрая (Rust), хорошая для production, фильтрация, self-hosting или облако, open source. Недостатки: меньше community чем у Pinecone, нет встроенных embeddings (нужна внешняя модель). Когда использовать: production-системы, где важны производительность и self-hosting.

Weaviate — GraphQL-API с встроенными эмбеддингами

Weaviate — это векторная база данных, написанная на Go, с встроенными моделями для генерации эмбеддингов. Ты не генерируешь эмбеддинги отдельно, Weaviate делает это автоматически.

import weaviate

# Подключение (локально)
client = weaviate.connect_to_local()

# Создаём коллекцию с автоматическими эмбеддингами
articles = client.collections.create(
    name="Article",
    vectorizer_config=weaviate.Configure.Vectorizer.text2vec_openai(),
    # Weaviate генерирует эмбеддинги автоматически!
)

# Добавляем объект (без ручного создания векторов!)
articles.data.insert({
    "title": "AI программирование 2026",
    "content": "Полный текст статьи...",
    "category": "programming"
})
# Weaviate генерирует вектор автоматически

# Семантический поиск (near_text, а не near_vector!)
results = articles.query.near_text(
    query="Как работает AI программирование?",
    limit=5,
    filters=Filter.by_property("category").equal("programming")
)

for obj in results.objects:
    print(f"{obj.properties['title']}: {obj.properties['content'][:100]}")

Преимущества: встроенные эмбеддинги (не нужна отдельная модель), GraphQL-API, Hybrid Search (вектор + ключевые слова), мультимодальность (текст, изображение, аудио). Недостатки: сложная конфигурация, высокие требования к ресурсам, меньше гибкости в выборе модели эмбеддинга. Подойдёт для: проектов, где важен Hybrid Search и ты не хочешь самостоятельно управлять эмбеддингами.

Chroma — самая простая интеграция для Python

Chroma (ранее ChromaDB) — самая простая векторная база данных для Python. Она написана на Python и не требует отдельного сервера, всё работает в одном процессе.

import chromadb

# Память или постоянное хранилище
client = chromadb.PersistentClient(path="./chroma_data")
# Или в памяти: client = chromadb.Client()

# Создаём коллекцию
collection = client.create_collection(
    name="agent_memory",
    metadata={"description": "Долгосрочная память AI-агента"}
)

# Добавляем (Chroma автоматически генерирует эмбеддинги с моделью по умолчанию!)
collection.add(
    documents=["Python — язык программирования."],
    metadatas=[{"source": "wiki", "category": "programming"}],
    ids=["1"]
)

# Или со своими эмбеддингами:
# collection.add(embeddings=[[0.12, ...]], documents=[...], ids=[...])

# Семантический поиск
results = collection.query(
    query_texts=["Что такое Python?"],
    n_results=5,
    where={"category": "programming"}  # Фильтр по метаданным
)

for doc, score, meta in zip(
    results["documents"][0],
    results["distances"][0],
    results["metadatas"][0]
):
    print(f"Score: {score:.4f} - {doc} (Source: {meta['source']})")

Преимущества: самая простая интеграция (3 строки кода), бесплатно, не требует сервера, автоматические эмбеддинги с моделью по умолчанию. Недостатки: не предназначена для масштабирования (миллионы+ векторов), меньше функций чем Qdrant/Weaviate. Подойдёт для: прототипов, разработки, небольших проектов, локального тестирования.

Pinecone — управляемая облачная векторная база данных

Pinecone — полностью управляемая облачная векторная база данных. Никакой инфраструктуры, никакого обслуживания, никаких проблем с масштабированием, но платная.

from pinecone import Pinecone

pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"])
index = pc.Index("agent-memory")

# Upsert
index.upsert(
    vectors=[
        {
            "id": "1",
            "values": [0.12, -0.34, 0.56],  # 1536-мерный
            "metadata": {"text": "Python — язык программирования.", "category": "programming"}
        }
    ]
)

# Запрос с фильтром
results = index.query(
    vector=[0.11, -0.32, 0.55],
    top_k=5,
    include_metadata=True,
    filter={"category": {"$eq": "programming"}}
)

for match in results["matches"]:
    print(f"Score: {match['score']:.4f} - {match['metadata']['text']}")

Преимущества: полностью управляется, масштабируется (миллиарды векторов), никакой инфраструктуры, serverless-вариант. Недостатки: стоит денег (от ~70$/месяц), привязка к поставщику, данные находятся в облаке. Подойдёт для: enterprise-проектов, когда ты не хочешь управлять инфраструктурой и есть бюджет.

Сравнение

Функция	Qdrant	Weaviate	Chroma	Pinecone
Хостинг	Self/Cloud	Self/Cloud	Self/Local	Только облако
Язык	Rust	Go	Python	Go
Эмбеддинги	Внешние	Встроенные	Внешние/По умолчанию	Внешние
Hybrid Search	Да	Да	Нет	Да
Масштабируемость	Высокая	Высокая	Средняя	Очень высокая
Стоимость	OSS/облако	OSS/облако	Бесплатно	От ~70$/месяц
Фильтрация	Да (Payload)	Да (GraphQL)	Да (where)	Да (metadata)
Мультимодальность	Нет	Да (текст/изображение/аудио)	Нет	Нет
Подойдёт для	Production	Сложные/Hybrid	Прототип	Enterprise

Мои рекомендации:

• Разработка/Прототип: Chroma, 3 строки кода, бесплатно, без сервера
• Production (Self-Hosted): Qdrant, быстрая, Rust, open source, хорошо документирована
• Production (Managed): Pinecone, без инфраструктуры, если есть бюджет
• Нужен Hybrid Search: Weaviate, единственная с настоящим Hybrid Search (вектор + ключевые слова)

RAG-пайплайн с векторными базами данных

RAG (Retrieval-Augmented Generation) — самый распространённый сценарий использования векторных баз данных в AI-агентах. Вот полный пайплайн:

from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_qdrant import QdrantVectorStore
from langchain.text_splitter import RecursiveCharacterTextSplitter

# 1. Загружаем документы и разбиваем на куски
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,        # 500 токенов на кусок
    chunk_overlap=100,     # 100 токенов перекрытия между кусками
    separators=["\n\n", "\n", ". ", " "]
)
chunks = text_splitter.split_text(document_text)
# chunks = ["Первый раздел...", "Второй раздел...", ...]

# 2. Генерируем эмбеддинги и сохраняем в Qdrant
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vector_store = QdrantVectorStore.from_texts(
    chunks,
    embeddings,
    url="http://localhost:6333",
    collection_name="knowledge_base"
)

# 3. RAG-запрос: находим релевантные документы
llm = ChatOpenAI(model="gpt-4o", temperature=0)
retriever = vector_store.as_retriever(search_kwargs={"k": 5})

# 4. Генерируем ответ, используя найденные документы как контекст
from langchain.chains import RetrievalQA
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=retriever,
    return_source_documents=True  # Показывает, какие документы использовались
)

result = qa_chain.invoke({"query": "Что такое AI программирование?"})
print(f"Ответ: {result['result']}")
print(f"Источники: {len(result['source_documents'])} документов использовано")

Что здесь происходит:

1. Chunking: текст документа разбивается на куски по 500 токенов (с 100 токенами перекрытия, чтобы не потерять контекст)
2. Эмбеддинги + Сохранение: каждый кусок превращается в вектор и сохраняется в Qdrant
3. Retrieval: вопрос пользователя превращается в вектор, и Qdrant находит 5 похожих кусков
4. Генерация: LLM получает вопрос + 5 найденных кусков как контекст и генерирует ответ

RAG в многоагентных системах

В многоагентной системе каждый агент может иметь свою собственную векторную базу данных:

# Research Agent: ищет в данных веб-скрейпинга
research_db = QdrantVectorStore(collection_name="web_research", ...)

# Code Agent: ищет в документации кода
code_db = QdrantVectorStore(collection_name="code_docs", ...)

# Support Agent: ищет в базе знаний
support_db = QdrantVectorStore(collection_name="kb_articles", ...)

Лучшие практики

1. Оптимизация размера chunks

Размер chunk является критическим параметром для качества RAG:

• Слишком маленький (100 токенов): Теряется контекст — один chunk не имеет смысла сам по себе
• Слишком большой (2000 токенов): Неточный поиск — вектор представляет слишком много разных тем
• Рекомендация: 500-1000 токенов с перекрытием 100-200 токенов

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=100,
    separators=["\n\n", "\n", ". ", " "]  # Натуральные точки разделения
)

2. Использование метаданных

Метаданные позволяют фильтровать результаты, что критично для больших баз данных:

# Сохранение с метаданными
collection.add(
    documents=["Статья о Python"],
    metadatas=[{
        "category": "programming",
        "date": "2026-07",
        "author": "IRC",
        "source": "wiki",
        "language": "de"
    }],
    ids=["1"]
)

# Фильтрованный поиск: только немецкие статьи о программировании
results = collection.query(
    query_texts=["Python"],
    where={"$and": [
        {"category": {"$eq": "programming"}},
        {"language": {"$eq": "de"}}
    ]},
    n_results=5
)

3. Выбор модели embedding

Модель	Размерность	Стоимость	Применение
text-embedding-3-small	1536	$0.02/M tokens	Стандарт, быстро
text-embedding-3-large	3072	$0.13/M tokens	Выше качество
sentence-transformers (локально)	384-768	Бесплатно	Разработка, приватность

Важно: При смене модели embedding все векторы нужно пересгенерировать. Разные модели создают несовместимые векторы.

4. Мониторинг

• Latency запросов: Должна быть ниже 100ms для хорошего UX
• Качество recall: Тест на известных парах query-document
• Потребление памяти: Векторы требуют памяти (1536 размерностей × 4 байта = ~6KB на вектор)
• Размер индекса: Qdrant и Pinecone показывают статистику индекса

5. Стратегия re-embedding

При обновлении модели embedding:

1. Создать новую collection
2. Пересгенерировать все документы и сохранить в новую collection
3. Провести тесты на новой collection
4. Переключить alias со старой collection на новую
5. Удалить старую collection

Ключевые моменты

• Векторная база данных: Хранит embeddings (числовые векторы) для семантического поиска
• Embeddings: Числовое представление текста, создаваемое моделями embedding (например, OpenAI text-embedding-3-small, 1536 размерностей)
• Семантический поиск: Cosine Similarity, Euclidean Distance, Dot Product
• RAG: Retrieval-Augmented Generation — LLM получает релевантные документы из векторной БД как контекст
• Chunking: Разделение текста на части (500-1000 токенов, 100-200 перекрытия)
• Инструменты: Qdrant (Rust, production), Weaviate (Go, гибридный поиск, встроенные embeddings), Chroma (Python, прототипы), Pinecone (облако, enterprise)
• Лучшие практики: Оптимизация размера chunk, метаданные для фильтрации, осознанный выбор модели embedding, мониторинг, re-embedding при смене модели

FAQ

Какую векторную БД выбрать для начала? Chroma для прототипов, 3 строки кода, бесплатно, без сервера. Qdrant для production, быстрый, open source, можно развернуть самостоятельно или в облаке.

Нужны ли мне векторные БД для каждого AI-агента? Нет. Только если агент должен искать по большим базам знаний, нуждается в долговременной памяти или использует RAG для доменспецифичных ответов. Для простых чат-ботов хватает context window LLM.

Могу ли я развертывать векторные БД локально? Да. Qdrant (Docker), Weaviate (Docker) и Chroma (Python-процесс) поддерживают локальное развертывание. Pinecone работает только в облаке.

Сколько векторов поместится в векторную БД? Qdrant и Pinecone: миллиарды. Weaviate: миллионы. Chroma: сотни тысяч (дальше становится медленнее). Обычно лимит ограничивает объем хранилища, а не сама программа.

Какие затраты на работу векторной БД?

• Chroma: бесплатно (self-hosted)
• Qdrant: бесплатно (self-hosted) или облако от ~25$/месяц
• Weaviate: бесплатно (self-hosted) или облако от ~25$/месяц
• Pinecone: от ~70$/месяц (только облако)
• Затраты на embedding: text-embedding-3-small стоит $0.02 за 1M токенов

Могу ли я использовать векторные БД с локальными моделями embedding? Да. Используй sentence-transformers (например, all-MiniLM-L6-v2) для бесплатного локального embedding. Векторы меньше (384 размерности), качество ниже, чем у OpenAI, но для многих случаев достаточно. Идеально для приватных данных.

Рекомендуемая литература