В первой части этого цикла статей мы увидели, что экспорт данных ChatGPT - это нечто большее, чем просто техническая функция. Экспортированные данные - это коллекция мыслей, идей, анализов и разговоров, которые накапливались в течение длительного периода времени. Но пока эти данные хранятся только в виде архива на вашем жестком диске, они так и остаются архивом. Решающий шаг - сделать эту информацию снова пригодной для использования. Именно с этого начинается разработка персонального ИИ знаний.
Идея на самом деле удивительно проста: ИИ должен не только работать с общими знаниями, но и иметь доступ к вашим собственным данным. Он должен уметь искать информацию в предыдущих разговорах, находить подходящий контент и включать его в новые ответы. Таким образом, обычный ИИ превращается в своего рода цифровую память. Это вторая часть цикла статей, в которой мы рассмотрим практическую сторону вопроса.
Teil 1 der Serie: Der unterschätzte Schatz im ChatGPT-Datenexport
Während wir in diesem zweiten Teil konkret in die Praxis einsteigen, lohnt sich ein Blick auf den ersten Artikel dieser Serie. Dort geht es um die grundlegende Frage, warum der ChatGPT-Datenexport überhaupt so interessant ist – und weshalb viele Nutzer sein Potenzial noch unterschätzen. Der Artikel zeigt, welche Daten tatsächlich im Export enthalten sind, wie daraus ein persönliches Wissensarchiv entstehen kann und warum genau dieser Schritt die Grundlage für eine eigene KI mit Gedächtnis bildet. Wenn Du verstehen möchtest, warum wir diese Pipeline überhaupt aufbauen und welchen strategischen Wert Deine eigenen Chatverläufe haben, solltest Du mit Teil 1 beginnen.
Прежде чем приступить к собственно реализации в следующей главе, давайте сначала посмотрим, как устроена такая система.
Основная идея системы RAG
Технической основой нашей системы является концепция, которая сегодня широко используется в мире ИИ: RAG, или Retrieval Augmented Generation. За этим термином скрывается очень практичный принцип.
Обычно языковая модель отвечает на вопросы, опираясь исключительно на знания, полученные в процессе обучения. Хотя эти знания обширны, они имеют два существенных ограничения:
- Во-первых, модель не знает никакой индивидуальной информации о ваших собственных проектах или мыслях.
- Во-вторых, он не может получить доступ к новым данным, созданным после обучения.
Именно в этом случае на помощь приходит система RAG. Вместо того чтобы генерировать ответ напрямую, сначала происходит нечто другое: система ищет в базе данных контент, соответствующий заданному вопросу. Затем этот контент передается в языковую модель в качестве контекста. Только после этого ИИ формулирует свой ответ. Проще говоря, процесс выглядит следующим образом:
- Вы задаете вопрос →
- система выполняет поиск в базе знаний →
- найден соответствующий контент →
- Это содержание передается ИИ в виде контекста →
- ИИ генерирует ответ.
Решающее преимущество очевидно: ИИ может использовать информацию, которая не была частью его первоначального обучения.
Именно здесь и пригодятся ваши данные ChatGPT. Если интегрировать эти разговоры в базу знаний, ИИ сможет обращаться к ним в дальнейшем. Он может находить предыдущие идеи, использовать аргументы из старых диалогов или принимать во внимание анализ прошлых бесед. Таким образом, система начинает „запоминать“ ваши собственные мысли.
Строительные блоки нашей системы
Для этого нам нужно несколько компонентов, которые работают вместе. К счастью, сегодня техническая инфраструктура для этого гораздо проще, чем несколько лет назад. По своей сути наша система состоит из четырех центральных компонентов.
- Первый строительный блок - это Экспорт данных ChatGPT. Вот наши исходные данные. Здесь содержатся все разговоры, которые мы ранее вели с ИИ.
- Второй строительный блок - это Модель встраивания. Эта модель переводит текст в математические векторы. Это позволяет сравнивать тексты по их смыслу.
- Третий строительный блок - это Векторная база данных. В нашем случае мы используем Qdrant. Эта база данных хранит математические представления текстов и обеспечивает быстрый семантический поиск.
- Четвертый строительный блок - это локальная языковая модель, которая работает через Ollama. Эта модель впоследствии формулирует реальные ответы.
Эти четыре компонента тесно взаимодействуют друг с другом.
- Экспорт данных обеспечивает содержание.
- Модель встраивания делает их машиночитаемыми.
- Векторная база данных сохраняет и ищет их.
- В итоге языковая модель генерирует понятные ответы.
Все вместе они составляют основу персонального ИИ знаний.
Поток данных с первого взгляда
Чтобы система работала, данные должны пройти несколько этапов. Первый шаг - это экспорт данных ChatGPT, который мы уже создали в первой статье. Содержащиеся в нем разговоры сначала извлекаются из JSON-файлов. Затем эти тексты необходимо подготовить. Большие истории чатов разбиваются на более мелкие части, так называемые текстовые фрагменты. Это делает последующий поиск гораздо более эффективным.
На следующем этапе мы генерируем вкрапления из этих фрагментов текста. Каждый текст описывается математически. Тексты с похожим смыслом получают похожие векторы. Затем мы сохраняем эти векторы в нашей векторной базе данных Qdrant.
Это означает, что самая важная часть инфраструктуры уже создана. Когда вопрос задается позже, происходит следующее:
- Вопрос также преобразуется в вектор.
- База данных ищет тексты с похожим смыслом.
- Эти отрывки текста передаются в языковую модель в качестве контекста.
- Модель использует эту информацию, чтобы сформулировать ответ.
Этот процесс гарантирует, что ИИ не только использует общие знания, но и может получить доступ к вашим собственным данным.
Что получится в итоге
Как только система настроена, работа с ИИ заметно меняется. Теперь вы работаете не просто с общей языковой моделью, а с ИИ, который может получить доступ к вашим собственным данным. Это открывает совершенно новые возможности. Например, вы можете задавать такие вопросы, как:
„Говорил ли я когда-нибудь с ИИ на эту тему?“
„Какие идеи у меня уже были по поводу этого проекта?“
„Какие аргументы я привел в предыдущих беседах?“
Затем ИИ просматривает ваши разговоры и находит подходящий контент. Вместо того чтобы просто дать общий ответ, он может обратиться к предыдущим мыслям, обобщить старые анализы или распознать связи между разными разговорами.
Другими словами, ИИ начинает работать с вашим собственным архивом знаний. Таким образом, простой чат превращается в систему, способную поддерживать ваше мышление в долгосрочной перспективе. Именно эту систему мы будем шаг за шагом создавать в следующих главах. В следующем разделе мы приступим к практической работе и сначала подробно рассмотрим экспорт данных ChatGPT. Ведь прежде чем создавать базу знаний, нам нужно понять, как на самом деле структурированы наши данные.
Текущий обзор использования локальных систем искусственного интеллекта
Подготовка: понимание экспорта данных ChatGPT
В первой статье этого цикла мы уже создали экспорт данных ChatGPT и загрузили его в виде ZIP-файла. На первый взгляд, этот файл может показаться несколько непримечательным - архив с некоторыми техническими файлами, который поначалу больше похож на резервную копию, чем на ценный набор данных. Однако этот архив содержит основу для всей нашей системы знаний.
Прежде чем мы начнем загружать эти данные в базу данных или подключать их к искусственному интеллекту, нам нужно понять, как структурирован экспорт. Ведь только если мы знаем, какая информация содержится и как она структурирована, мы сможем впоследствии полноценно ее обработать. В этой главе мы рассмотрим, как структурирован экспорт данных, какие файлы действительно важны и как мы можем превратить этот технический архив в полезную основу для системы знаний ИИ.
Распакуйте ZIP-файл
Первый шаг тривиален, но тем не менее важен: нам нужно распаковать скачанный архив. Обычно он доступен в виде классического ZIP-файла. В зависимости от степени использования он может иметь разный размер. Некоторые пользователи получают архив размером в несколько сотен мегабайт, другие - в несколько гигабайт.
После распаковки файла создается папка с несколькими файлами и вложенными папками. Точная структура может немного отличаться, но обычно вы найдете несколько JSON-файлов и, возможно, другие файлы с дополнительной информацией.
Для многих пользователей такая структура поначалу кажется несколько технической. Но если присмотреться, то можно быстро распознать закономерность: данные организованы достаточно аккуратно и имеют четкую структуру. Это хорошая новость, потому что именно такая структура позволяет в дальнейшем автоматически обрабатывать содержимое.
Структура данных чата
Наиболее важной частью экспорта являются фактические данные чата. Эти беседы обычно хранятся в одном или нескольких файлах JSON. JSON - это широко распространенный формат данных, который часто используется для хранения структурированной информации.
Такой файл не просто содержит длинный текст. Вместо этого диалог делится на отдельные элементы. Как правило, диалог состоит из нескольких сообщений. Каждое сообщение содержит такую информацию, как
- фактический текст сообщения
- роль отправителя (пользователь или искусственный интеллект)
- отметка времени
- частично дополнительные метаданные
Это позволяет реконструировать весь ход диалога. Например, диалог начинается с вопроса пользователя. За ним следует ответ от ИИ. Затем могут следовать дополнительные вопросы и ответы. Каждое из этих сообщений сохраняется отдельно.
У этого есть одно важное преимущество: впоследствии мы сможем точно определить, кто что сказал и как развивался разговор. Это особенно важно для нашей системы знаний, поскольку в дальнейшем мы хотим искать и анализировать именно этот контент.
Какие данные нам действительно нужны
Хотя в экспорте содержится много информации, не вся она нужна для нашей системы знаний. Самый важный компонент - это тексты разговоров. Эти тексты содержат фактическое содержание: Идеи, анализ, вопросы и ответы. Именно это содержание мы хотим искать в дальнейшем.
Некоторые метаданные также могут быть полезны. К ним относятся, например
- Временная метка
- Название беседы
- Возможно, внутренние идентификационные номера
Эта информация помогает нам в дальнейшем лучше сортировать контент или распределять беседы по времени. Другие компоненты экспорта менее важны для нашего проекта. К ним относятся, например, некоторые технические метаданные, которые представляют интерес только для внутреннего функционирования платформы.
Поэтому для создания базы знаний мы намеренно сосредоточились на самом необходимом: текстах разговоров и базовой контекстной информации. Чем четче мы структурируем эти данные, тем лучше наш ИИ сможет работать с ними в дальнейшем.
Первый обзор данных
Прежде чем приступить к работе с автоматическими скриптами, стоит взглянуть на сами данные. Для этого откройте один из JSON-файлов с помощью простого текстового редактора или программы, которая может хорошо отображать JSON-файлы. Многие редакторы кода, такие как Visual Studio Code, очень хорошо подходят для этого, но и простые текстовые редакторы тоже работают.
При первом взгляде на файл вы, вероятно, увидите довольно большой объем структурированных данных. Файлы JSON состоят из вложенных элементов, то есть полей данных, которые, в свою очередь, содержат другие поля. Поначалу это может показаться немного сложным, но, проявив немного терпения, вы быстро разберетесь в основной структуре. Например, вы увидите, что разговор состоит из нескольких сообщений и что каждое сообщение представляет собой отдельный объект. Сам текст обычно находится в четко различимом поле.
Эта первая проверка имеет важную цель: она поможет вам понять, как структурированы ваши данные. Потому что в следующей главе мы будем использовать именно эту структуру для автоматического считывания разговоров и подготовки их для нашей системы знаний. Другими словами: Мы шаг за шагом превращаем архив технических данных в пригодную для использования базу знаний. Именно с этого мы и начнем в следующей главе. Цель состоит в том, чтобы извлечь данные из чата и подготовить их таким образом, чтобы впоследствии в них можно было осуществлять эффективный поиск.
Подготовка данных: От разговоров к анализируемым текстам
После распаковки экспортированных данных ChatGPT в предыдущей главе и получения начального представления о структуре, теперь начинается собственно техническая часть нашего проекта. Хотя экспортированные данные уже готовы, в таком виде они еще не оптимально подходят для нашей системы знаний.
Причина проста: истории чатов обычно длинные, содержат много тем и хранятся в структуре, удобной для чтения человеком, но не идеальной для семантического поиска или векторных баз данных. Чтобы наш ИИ мог впоследствии находить релевантный контент, сначала нужно обработать эти исходные данные. По сути, это означает три вещи:
- Извлеките разговоры из файлов JSON
- грамотно структурировать тексты
- Разделите содержимое на более мелкие части
Этот процесс является совершенно обычным шагом в современных системах искусственного интеллекта и часто называется предварительной обработкой.
Почему необработанные данные не подходят для непосредственного использования
Если вы посмотрите на один из JSON-файлов, то заметите, что один чат часто состоит из множества сообщений. Типичный диалог может выглядеть, например, так:
- Вопрос
- Ответить
- Запрос
- новая декларация
- дополнительная информация
- Резюме
Некоторые разговоры могут содержать сотни или даже тысячи слов. Для человека это не проблема. Мы просто читаем диалог сверху вниз.
Однако для поиска с помощью искусственного интеллекта это работает хуже. Причина в том, что один чат часто содержит несколько тем. Если впоследствии мы будем выполнять семантический поиск, система должна найти как можно более точные фрагменты текста, а не целые беседы с большим количеством различного контента.
Именно поэтому большие тексты разбиваются на более мелкие части. Эти части называются кусками. Кусок - это просто небольшой блок текста, содержащий связную мысль. Этот метод значительно повышает качество поиска в дальнейшем.
Извлечение историй чатов
Первый практический шаг - чтение содержимого из JSON-файлов. Для этого мы используем небольшой скрипт на Python. Python особенно подходит для таких задач, поскольку содержит множество библиотек для обработки данных и искусственного интеллекта.
Сначала создайте новый файл, например:
extract_chats.py
Затем мы добавляем простой скрипт, который загружает данные чата.
import json
with open("conversations.json", "r", encoding="utf-8") as f:
data = json.load(f)
print("Anzahl der Gespräche:", len(data))
Запустив этот сценарий, вы увидите, сколько разговоров содержится в экспортированном файле. Теперь давайте извлечем фактические тексты.
texts = []
for conversation in data:
if "mapping" in conversation:
for node in conversation["mapping"].values():
message = node.get("message")
if message:
content = message.get("content")
if content and "parts" in content:
text = " ".join(content["parts"])
texts.append(text)
print("Extrahierte Textabschnitte:", len(texts))
Этот скрипт проходит через структуру JSON и собирает все текстовые части из разговоров. Это означает, что мы уже выполнили самую важную часть: мы извлекли содержимое из технического формата экспорта.
Создание фрагментов текста
Теперь наступает следующий важный этап: разбивка на фрагменты. Вместо того чтобы сохранять целые разговоры, мы делим тексты на небольшие фрагменты.
Типичный размер таких фрагментов текста составляет от 300 до 800 слов или около 500 лексем. Ниже приведен простой пример разделения текста на фрагменты.
def split_text(text, chunk_size=500):
words = text.split()
chunks = []
for i in range(0, len(words), chunk_size):
chunk = " ".join(words[i:i+chunk_size])
chunks.append(chunk)
return chunks
Теперь мы можем применить эту функцию к нашим текстам.
all_chunks = []
for text in texts:
chunks = split_text(text)
all_chunks.extend(chunks)
print("Gesamtzahl der Chunks:", len(all_chunks))
Теперь мы создали множество небольших текстовых блоков из истории наших чатов. Эти текстовые блоки идеально подходят для последующего поиска в векторной базе данных.
Добавить метаданные
Помимо самого текста, дополнительная информация может быть очень полезной. Эти так называемые метаданные помогают нам в дальнейшем лучше сортировать или фильтровать содержимое. Типичными метаданными могут быть
- Дата разговора
- Название беседы
- Источник (ChatGPT Export)
- Идентификатор вызова
Мы можем сохранить эту информацию вместе с текстом, например, так:
documents = []
for conversation in data:
title = conversation.get("title", "Unbekannt")
if "mapping" in conversation:
for node in conversation["mapping"].values():
message = node.get("message")
if message:
content = message.get("content")
if content and "parts" in content:
text = " ".join(content["parts"])
chunks = split_text(text)
for chunk in chunks:
documents.append({
"text": chunk,
"title": title
})
Это уже позволило придать нашим данным более совершенную структуру. Вместо запутанного архива чатов мы теперь имеем коллекцию из множества небольших текстовых разделов, каждый из которых снабжен контекстной информацией.
Именно эта структура будет иметь решающее значение на следующем этапе. Ведь теперь мы можем начать генерировать вкрапления из этих текстов - то есть математические представления содержимого, которые впоследствии будут сохранены в нашей векторной базе данных. Именно этому и посвящена следующая глава.
Создание вкраплений
В предыдущей главе мы уже привели данные ChatGPT в пригодный для использования вид. Мы извлекли беседы из JSON-файлов, очистили тексты и разделили их на более мелкие части - так называемые чанки.
Однако для того, чтобы наш ИИ смог осуществлять полноценный поиск контента, еще не хватает одного важного шага. Тексты должны быть переведены в форму, которую смогут сопоставить машины. Именно здесь на помощь приходят вкрапления.
Вкрапления - это математические представления текстов. Они позволяют компьютерам сравнивать смысл текстов. Два текста с похожим содержанием получают одинаковые векторы - даже если в них используются разные слова. Это именно то свойство, которое нам нужно для нашей системы знаний. Ведь наш ИИ должен искать не только одинаковые слова, но и тексты с похожим содержанием.
Что такое вкрапления
По сути, вложение - это список чисел. Эти числа описывают смысл текста в математическом пространстве. Каждый текст преобразуется в так называемый вектор. Такой вектор может выглядеть, например, так:
[0.134, -0.876, 0.442, 0.921, -0.223, ...]
Один вектор может содержать несколько сотен или даже тысяч чисел. Эти числа, конечно, не понятны человеку напрямую. Однако для машин они идеально подходят для вычисления сходства между текстами. Если два текста имеют схожее содержание, их векторы сближаются в математическом пространстве. Пример:
- Текст A„Как я могу экспортировать данные ChatGPT?“
- Текст B: „Как загрузить мои разговоры в ChatGPT?“
Несмотря на разные формулировки, оба текста в основном описывают одну и ту же тему. Хорошая модель встраивания распознает это сходство. Поэтому оба текста получают одинаковые векторы. Именно этот принцип мы будем использовать в дальнейшем для семантического поиска.
Модели для встраивания с Ollama
Для создания вкраплений нам нужна специальная модель. К счастью, для этого не обязательно использовать внешние облачные сервисы. Многие модели встраивания теперь могут работать локально, и именно здесь вступает в игру Ollama.
Поскольку Ollama уже работает в вашей системе, мы можем встроить туда модель install. Очень хорошей моделью является, например:
nomic-embed-text
Приручить его можно с помощью следующей команды 1TP12:
ollama pull nomic-embed-text
Другими популярными моделями являются
- mxbai-embed-large
- bge-large
- весь фильм
Для наших целей nomic-embed-text является очень хорошей отправной точкой. Эта модель генерирует высококачественные вкрапления и работает локально без каких-либо проблем.
Создавайте вкрапления локально
Теперь мы хотим расширить наш скрипт на Python, чтобы он мог генерировать вкрапления. Сначала 1TP12Создадим библиотеку, с которой Python сможет взаимодействовать Ollama.
пип install оллама
Теперь мы можем обращаться к модели встраивания непосредственно из Python. Ниже приведен простой пример:
import ollama
response = ollama.embeddings(
model="nomic-embed-text",
prompt="Wie exportiere ich meine ChatGPT-Daten?"
)
print(len(response["embedding"]))
Если все получилось, вы получите вектор с несколькими сотнями чисел.
Теперь давайте применим это к нашим чатам.
embeddings = []
for doc in documents:
text = doc["text"]
result = ollama.embeddings(
model="nomic-embed-text",
prompt=text
)
vector = result["embedding"]
embeddings.append({
"text": text,
"embedding": vector,
"title": doc["title"]
})
С его помощью мы создаем вектор для каждого участка текста. В дальнейшем эти векторы сохраняются в нашей базе данных.
Почему этот шаг имеет решающее значение
Встраивания лежат в основе современных систем знаний. Без вкраплений мы могли бы искать тексты только с помощью классического поиска по ключевым словам. Это означало бы, что система находила бы только контент, содержащий одинаковые слова. Но язык редко работает так просто. Например, пользователь может спросить:
„Как я обработал данные ChatGPT?“
Однако первоначально разговор можно было сформулировать так:
„Как я могу проанализировать экспорт данных ChatGPT?“
Простой поиск может не распознать эту связь. С вкраплениями все иначе. Поскольку оба текста имеют схожие значения, их векторы близки друг к другу в математическом пространстве. Поэтому наша база данных может найти совпадающий контент, даже если формулировки отличаются. Именно эта способность делает семантический поиск таким мощным. Он позволяет ИИ искать не просто слова, а смысл.
Именно поэтому эмбеддинги являются центральным строительным блоком нашей системы. В следующей главе мы будем развивать это и installieren нашу базу данных векторов. В ней мы будем хранить сгенерированные векторы - и таким образом создадим основу для нашего персонального ИИ знаний.
Qdrant 1TP12Добавление и настройка
После создания вкраплений для данных чата в предыдущей главе у нас появилась коллекция участков текста и связанных с ними векторов. Эти векторы математически описывают смысл текстов и, таким образом, служат основой для семантического поиска. Однако в настоящее время эти данные доступны только в рабочей памяти нашего скрипта или в виде простых списков. Нам нужна специализированная память, чтобы наш ИИ мог эффективно обращаться к ней в дальнейшем.
Именно здесь на помощь приходит векторная база данных. Векторная база данных оптимизирована для хранения большого количества таких вкраплений и быстрого поиска похожих векторов. Для нашего проекта мы используем Qdrant, современную базу данных с открытым исходным кодом, которая была специально разработана для приложений ИИ.
В этой главе 1TP12 мы установим Qdrant, запустим сервер и подготовим базу данных, чтобы впоследствии можно было легко импортировать данные чата.
Что такое Qdrant
Qdrant - это специализированная база данных для так называемого векторного поиска. В то время как традиционные базы данных хранят информацию в таблицах - например, имена, числа или тексты, - векторные базы данных работают с математическими представлениями данных.
Это означает, что вместо того, чтобы просто сохранять текст, Qdrant сохраняет связанные с ним вкрапления. Большое преимущество заключается в поиске. Если позже будет задан вопрос, наша система также преобразует его в вектор. Затем Qdrant может с молниеносной скоростью вычислить, какие из сохраненных текстов наиболее похожи на этот вектор. Это позволяет, например, найти:
- какие отрывки из чата тематически соответствуют вопросу
- какие предыдущие разговоры содержат аналогичный контент
- какие идеи могут быть актуальны в вашем архиве
Именно поэтому Qdrant сегодня используется во многих современных системах искусственного интеллекта - от поиска по документам до сложных помощников в работе со знаниями. Еще одно преимущество: Qdrant имеет открытый исходный код, быстро адаптируется к 1TP12 и работает без проблем на обычной локальной машине.
Установка Qdrant
Самый простой способ installieren Qdrant - это Docker. Если Docker доступен на вашей машине, вы можете запустить сервер с помощью одной команды. Здесь вы можете Скачать Docker, если вы еще не установили его на свой компьютер installiert.
docker run -p 6333:6333 qdrant/qdrant
Эта команда запускает сервер Qdrant и открывает стандартный порт 6333. Через этот порт наши скрипты смогут в дальнейшем взаимодействовать с базой данных.
Если вы не хотите использовать Docker, есть и другие способы installiere Qdrant, например, через локальный бинарник или менеджер пакетов. Однако во многих практических проектах Docker зарекомендовал себя как самый простой и стабильный вариант.
После запуска сервера Qdrant работает в фоновом режиме и ожидает запросов. Теперь вы можете проверить, доступен ли сервер. Для этого откройте в браузере следующий адрес:
http://localhost:6333
Если все прошло успешно, должно появиться простое сообщение о состоянии. Теперь сервер готов к следующим шагам.
Первые шаги с Qdrant
Прежде чем мы сможем импортировать данные чата, нам нужно создать так называемую коллекцию. В Qdrant коллекция сравнима с таблицей в классической базе данных. Она содержит наши векторы и соответствующие данные.
Сначала мы installiere библиотеку Python для Qdrant:
pip install qdrant-client
Теперь мы можем установить соединение с базой данных в нашем Python-скрипте.
from qdrant_client import QdrantClient
client = QdrantClient("localhost", port=6333)
Если этот код выполняется без сообщения об ошибке, соединение успешно. Теперь мы создадим коллекцию для данных нашего чата.
from qdrant_client.models import VectorParams, Distance client.recreate_collection( collection_name="chatgpt_archive", vectors_config=VectorParams(size=768, distance=Distance.COSINE), )
Наиболее важными параметрами здесь являются
- имя_коллекции - имя нашей базы данных
- размер - длина векторов встраивания
- расстояние - метод расчета сходства
Размер вектора зависит от используемой модели встраивания. Многие модели работают с векторами размером 768 или 1024. Функция косинусного расстояния - один из самых распространенных методов расчета сходства между текстами. Это означает, что наша база данных уже готова к использованию.
Структура данных плана
Прежде чем импортировать данные, стоит вкратце рассмотреть структуру, которую мы хотим сохранить. Каждая запись в нашей базе данных векторов будет состоять из нескольких компонентов:
- ID - уникальный идентификатор
- Встраивание - вектор текста
- Полезная нагрузка - Дополнительная информация о тексте
Полезная нагрузка может содержать, например
- оригинальный текст
- название разговора
- дата
- другие метаданные
Пример записи данных может выглядеть следующим образом:
{
"id": 1,
"vector": [0.123, -0.452, 0.889, ...],
"payload": {
"text": "Wie kann ich meinen ChatGPT-Datenexport analysieren?",
"title": "Datenanalyse"
}
}
Такая структура имеет большое преимущество. Векторы используются для семантического поиска, а полезная нагрузка содержит всю информацию, которую мы хотим отобразить или проанализировать позже. Это означает, что наша система остается гибкой и может быть легко расширена в дальнейшем.
Это означает, что самая важная часть инфраструктуры уже подготовлена. Наш сервер Qdrant запущен, база данных настроена, и мы знаем, какую структуру будут иметь наши данные. В следующей главе мы приступим к решающему шагу: импортируем данные ChatGPT в базу данных и превратим наш архив разговоров в настоящую базу знаний с возможностью поиска.
Импорт данных ChatGPT в Qdrant
Теперь, когда мы создали Qdrant installiert и коллекцию в предыдущей главе, техническая основа для нашей базы знаний создана. Наши вкрапления уже существуют - мы создали их из данных ChatGPT - и Qdrant работает как сервер базы данных на нашей машине.
Теперь наступает решающий этап: мы загружаем наши данные в базу данных. Мы сохраняем не только сами векторы, но и связанные с ними тексты и метаданные. Эта комбинация позволяет нашему ИИ впоследствии находить релевантный контент и использовать его в ответах. В этой главе мы создаем фактическую базу знаний нашей системы.
Сохранить вставки
Во-первых, нам нужно перенести сгенерированные вкрапления в базу данных. Каждая запись в Qdrant состоит из трех компонентов:
- идентификатор
- вектор (встраивание)
- полезная нагрузка с дополнительными данными
В нашем случае, например, полезная нагрузка содержит
- текстовый раздел
- название разговора
- Возможно, дополнительные метаданные
В Python мы можем сравнительно легко подготовить такую структуру. Пример:
points = []
for idx, item in enumerate(embeddings):
points.append({
"id": idx,
"vector": item["embedding"],
"payload": {
"text": item["text"],
"title": item["title"]
}
})
В результате формируется список точек данных, который мы можем сохранить в Qdrant. Каждая точка данных содержит текстовый фрагмент, соответствующий вектор и дополнительную контекстную информацию. Эта структура впоследствии ляжет в основу нашего семантического поиска.
Создание сценария импорта
Теперь мы подключаем наш сценарий Python к Qdrant и передаем данные. Для этого мы используем Python-клиент Qdrant, который мы рассматривали в предыдущей главе 1TP12. Импорт может выглядеть, например, так:
from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct
client = QdrantClient("localhost", port=6333)
points = []
for idx, item in enumerate(embeddings):
point = PointStruct(
id=idx,
vector=item["embedding"],
payload={
"text": item["text"],
"title": item["title"]
}
)
points.append(point)
client.upsert(
collection_name="chatgpt_archive",
points=points
)
print("Import abgeschlossen:", len(points), "Datensätze gespeichert.")
Команда upsert обеспечивает сохранение данных в коллекции. Если идентификатор уже существует, запись обновляется. В противном случае создается новая запись данных. В зависимости от размера экспорта ChatGPT этот импорт может занять несколько секунд или минут. Это совершенно нормально для больших наборов данных - например, нескольких тысяч текстовых разделов.
Тестовая база данных
После завершения импорта необходимо проверить, правильно ли были сохранены данные. Самая простая проверка - выполнить векторный поиск. Для этого мы сначала создадим вложение для тестового вопроса.
query = "Wie kann ich ChatGPT-Daten analysieren?" query_vector = ollama.embeddings( model="nomic-embed-text", prompt=query )["embedding"]
Теперь мы можем искать в Qdrant похожие векторы.
search_result = client.search( collection_name="chatgpt_archive", query_vector=query_vector, limit=3 )
Эта команда возвращает три наиболее похожих фрагмента текста из нашей базы данных. Мы можем вывести их, например, так:
for result in search_result:
print(result.payload["text"])
print("---")
Если все получилось, то теперь появятся разделы чата из вашего архива, соответствующие поисковому запросу. Теперь мы знаем: Наша база данных работает.
Первая аттестация
Этот момент - один из самых волнующих во всем проекте. Впервые становится очевидным, что наш архив чатов действительно можно использовать как источник знаний. Теперь вы можете опробовать различные поисковые запросы. Например:
- „Статья об искусственном интеллекте“
- „Система RAG“
- „Экспорт данных ChatGPT“
- „Идея стратегии“
В зависимости от содержания истории вашего чата Qdrant найдет подходящие фрагменты текста. Иногда вы будете удивлены тем, какой контент всплывает на поверхность. Разговоры, которые вы давно забыли, могут внезапно снова стать актуальными. Это наглядно показывает, почему такой подход так интересен. Ваши старые разговоры с ИИ больше не являются просто архивом. Они становятся базой знаний с возможностью поиска.
Таким образом, мы достигли важной вехи. Наши данные ChatGPT теперь полностью хранятся в векторной базе данных, и по ним можно осуществлять семантический поиск. В следующей главе мы сделаем еще один шаг вперед: соединим нашу базу знаний с самим ИИ. Это позволит языковой модели в будущем получать доступ к этим данным и включать их непосредственно в ответы.
Соединение ИИ с базой знаний
До этого момента мы уже создали большую часть инфраструктуры. Наши данные ChatGPT были извлечены из экспорта, разбиты на небольшие текстовые фрагменты, встроены и, наконец, сохранены в векторной базе данных Qdrant.
Однако наш ИИ еще не работает с этими данными. Хотя мы можем выполнить векторный поиск с помощью Python и найти подходящие отрывки текста, сам ИИ еще не знает об этом. Когда мы задаем ему вопрос, он по-прежнему использует только свои общие знания языка.
Поэтому следующим шагом будет соединение этих двух миров. Сейчас мы строим процесс, в котором ИИ сначала получает релевантный контент из базы знаний, а затем включает его в свой ответ. Именно в этом и заключается суть системы RAG.
Процесс запроса
Благодаря нашей системе знаний процесс запроса несколько меняется. До сих пор разговор с искусственным интеллектом обычно проходил следующим образом:
- Вы задаете вопрос →
- ИИ обрабатывает вопрос →
- ИИ генерирует ответ.
База данных знаний - это дополнительный шаг. Новый процесс выглядит следующим образом:
- Вы задаете вопрос →
- вопрос преобразуется во вложение →
- векторная база данных ищет похожие тексты →
- Эти тексты передаются в ИИ в виде контекста →
ИИ формулирует ответ. Это означает, что ИИ работает не только со своими обученными знаниями, но и с вашими собственными данными. Такой контекст часто делает ответы гораздо более точными и персонализированными.
Шаг извлечения
Первая часть этого процесса известна как извлечение. Retrieval означает „поиск“. На этом этапе наша система ищет в базе данных контент, соответствующий теме вопроса. Сначала мы создаем еще одно вложение для текущего вопроса.
query = "Welche Ideen hatte ich zur Nutzung meines ChatGPT-Datenexports?" query_vector = ollama.embeddings( model="nomic-embed-text", prompt=query )["embedding"]
Это вложение описывает смысл вопроса в математической форме. Теперь Qdrant может искать похожие векторы.
results = client.search( collection_name="chatgpt_archive", query_vector=query_vector, limit=5 )
Теперь база данных возвращает пять текстовых отрывков, которые лучше всего соответствуют вопросу. Эти текстовые отрывки составляют контекст для ИИ. Мы собираем их в список.
context_texts = [] for r in results: context_texts.append(r.payload["text"])
Теперь у нас есть коллекция соответствующих материалов из нашего архива чатов.
Передача контекста на Ollama
Теперь наступает решающий этап. Мы передаем этот контекст вместе с исходным вопросом нашей языковой модели. Теперь модель может использовать эту информацию для формулирования ответа.
Сначала мы создаем так называемую подсказку. Подсказка - это просто текст, который мы отправляем ИИ.
context = "\n\n".join(context_texts)
prompt = f"""
Du bist ein KI-Assistent, der mit meinem persönlichen Wissensarchiv arbeitet.
Nutze die folgenden Textausschnitte als Kontext:
{context}
Beantworte nun diese Frage:
{query}
"""
Теперь мы отправим это приглашение нашей языковой модели в Ollama.
response = ollama.chat(
model="llama3",
messages=[
{"role": "user", "content": prompt}
]
)
print(response["message"]["content"])
Теперь искусственный интеллект получает вопрос и соответствующие отрывки текста из нашей базы данных. Это позволяет ему генерировать ответы на основе наших собственных данных.
Генерация ответов
Последний шаг - собственно генерация ответа. Теперь языковая модель объединяет два источника знаний:
свои собственные знания
контекст из нашей базы знаний
Эта комбинация обладает особой силой. Модель может объяснять общие взаимосвязи и в то же время включать в себя конкретный контент из нашего архива. Пример: Если вы спросите:
„Какие идеи по использованию экспорта данных ChatGPT у меня возникли?“
ИИ теперь может получить доступ к предыдущим разговорам и создать на их основе структурированное резюме. Например, он может ответить:
- Вы говорили о создании личного архива знаний.
- Вы хотели разработать локальный ИИ с системой RAG.
- Вы разработали идею серии статей.
Без этапа извлечения информации ИИ вообще не знал бы об этом. С нашей системой ваш архив чатов становится настоящим источником знаний. На этом самая важная часть нашей системы завершена. Теперь у нас есть:
- местный искусственный интеллект через Ollama
- векторная база данных с данными нашего чата
- семантический поиск
- рабочий процесс RAG
В следующей главе мы проверим эту систему на практике и посмотрим, насколько хорошо работает наш ИИ личных знаний.
Первые запросы с вашими личными знаниями AI
Теперь, когда мы установили связь между нашим ИИ и базой знаний в предыдущей главе, система технически завершена. Наши данные ChatGPT находятся в векторной базе данных, ИИ может извлекать соответствующий контент, и весь процесс системы RAG работает.
Теперь наступает самая захватывающая часть проекта: первые реальные запросы. Ведь только теперь мы можем увидеть, действительно ли наша система делает то, на что мы рассчитывали, а именно: находит предыдущие разговоры, анализирует контент и генерирует содержательные ответы. В этой главе мы протестируем наш ИИ знаний, рассмотрим типичные случаи использования и возможные оптимизации.
Примеры запросов
Давайте начнем с простых вопросов. Хорошая стратегия - начать с вопросов, которые, как вы знаете, есть в архиве вашего чата. Например:
„Какие идеи по использованию экспорта данных ChatGPT у меня возникли?“
„Что я написал о системах RAG?“
„Какие стратегии использования искусственного интеллекта я обсуждал?“
Эти вопросы намеренно содержат открытые формулировки. Цель - не найти конкретный текст, а обнаружить тематически подходящее содержание. Когда вы задаете такой вопрос своей системе, процесс, который мы описали в предыдущей главе, происходит в фоновом режиме:
- Вопрос преобразуется во вставку.
- Векторная база данных ищет похожие участки текста.
- Эти отрывки текста передаются в ИИ в качестве контекста.
- ИИ генерирует ответ на основе этого контекста.
Результат может быть удивительным. Часто всплывают разговоры, о которых вы давно забыли. Старые идеи внезапно появляются на экране - иногда даже в совершенно новом контексте.
Именно в этом и заключается сила данного подхода. Ваш архив чатов становится источником знаний с возможностью поиска.
Качество ответов
Если вы попробуете выполнить несколько запросов, то поймете, что качество ответов может быть разным. Это совершенно нормально. Качество работы такой системы зависит от нескольких факторов. Одним из важных факторов является размер текстовых фрагментов. Если разделы слишком большие, они могут содержать несколько тем. Это делает поиск менее точным.
Однако если фрагменты слишком малы, необходимый контекст иногда отсутствует. Еще один фактор - модель встраивания. Разные модели по-разному распознают смысловые контексты. Некоторые из них особенно подходят для технических текстов, другие - для общеязыковых.
Количество полученных результатов также играет роль. Например, если вы извлекаете только два отрывка текста, важная информация может быть упущена. С другой стороны, если загрузить слишком много текстов, ИИ может столкнуться с трудностями при распознавании соответствующего контекста.
Впоследствии эти параметры можно будет легко скорректировать. Самое главное, чтобы базовая система работала.
Типичные проблемы
Как и в любой другой технической системе, здесь также могут возникнуть некоторые трудности. Частая проблема заключается в том, что база данных находит тексты, которые релевантны лишь частично. Это происходит потому, что семантический поиск всегда работает с вероятностями.
Другая проблема может возникнуть, если текст слишком сильно фрагментирован. Если мысль распределена по нескольким фрагментам, ИИ может столкнуться с трудностями при распознавании контекста.
Подсказка также играет определенную роль. Если подсказка неясна, ИИ может не оптимально использовать контекст. Пример лучшей подсказки может выглядеть следующим образом:
Используйте следующие фрагменты текста из моего архива знаний,
как можно точнее ответить на вопрос.
Если есть соответствующие материалы, кратко изложите их.
Такие небольшие корректировки могут значительно улучшить качество ответов.
Тонкая настройка
Как только система в основном заработает, начнется самая интересная часть: тонкая настройка. Здесь вы можете экспериментировать и шаг за шагом улучшать свою систему знаний. Некоторые типичные варианты оптимизации
- Настройка размера фрагмента
Иногда небольшие фрагменты текста дают лучшие результаты. В других случаях полезен дополнительный контекст. - Использование другой модели встраивания
Изменение модели может значительно улучшить качество семантического поиска. - Больше контекста для ИИ
Вы можете получить больше результатов из базы данных, например, десять отрывков текста вместо пяти. - Используйте метаданные
Если вы сохраните дополнительную информацию - например, дату или название вызова, - вы сможете впоследствии более точно отфильтровать поиск.
Эти настройки являются частью каждой настоящей системы RAG. Редко можно найти идеальную настройку для всех ситуаций. Но именно в этом и заключается привлекательность таких систем: их можно постоянно совершенствовать.
В этой главе мы провели первое полное тестирование нашей системы. Мы убедились, что наш ИИ личных знаний действительно способен искать информацию в старых разговорах и извлекать релевантный контент.
Это означает, что основная часть нашего проекта уже реализована. Но систему еще можно значительно расширить. Поэтому в следующей главе мы рассмотрим, как можно шаг за шагом интегрировать дополнительные источники данных и расширить свой личный архив знаний.
Расширения для вашей персональной системы знаний ИИ
Вы уже создали функционирующую систему с помощью предыдущей настройки. Ваши данные ChatGPT были извлечены, преобразованы в эмбеддинги, сохранены в Qdrant и, наконец, подключены к локальному ИИ. В результате получился ИИ, обладающий знаниями и способный получать доступ к предыдущим разговорам.
Но, строго говоря, мы находимся только в самом начале. Архитектура, которую вы построили, не ограничивается данными ChatGPT. Она работает с любым видом текста. Все, что может быть преобразовано в документы или текстовые файлы, может стать частью этой системы знаний. Именно здесь кроется реальный потенциал таких систем.
По сути, мы создали машину персональных знаний. И эту машину можно расширять шаг за шагом. В этой главе мы рассмотрим возможности, которые возникают в связи с этим, и то, как вы можете расширить свою систему в долгосрочной перспективе.
Интеграция дополнительных источников данных
Самый очевидный следующий шаг - добавить больше контента в свою базу знаний. Беседы в ChatGPT - хорошее начало, но они обычно представляют лишь часть ваших собственных знаний. Многие сведения доступны в других форматах. Например:
- собственные статьи
- Примечания
- PDF-документы
- Исследовательские документы
- Электронные книги
- Протоколы или списки идей
Все это содержимое может быть обработано так же, как и данные чата. Процесс остается идентичным:
- Извлечь текст
- Разделите текст на фрагменты
- Создание вкраплений
- Сохраните данные в Qdrant
Пример: Если вы написали множество собственных статей, вы можете импортировать эти тексты в свою базу знаний. Впоследствии ИИ сможет обращаться к ним и распознавать взаимосвязи. Например, вы можете спросить:
„Какие статьи я написал об искусственном интеллекте?“
или
„Какие аргументы я приводил по этой теме в прошлом?“
Затем ИИ выполняет поиск в архиве статей и использует найденный контент в качестве контекста. Таким образом, ваша система шаг за шагом превращается во всеобъемлющий архив знаний.
Несколько баз данных знаний
По мере увеличения объема данных может оказаться полезным разделить различные области. Qdrant позволяет создавать несколько коллекций. Каждая коллекция может представлять собой собственную базу знаний. Возможная система может выглядеть, например, так:
- Коллекция 1Беседы в чате
- Коллекция 2: Архив статей
- Коллекция 3: личные заметки
- Коллекция 4Техническая документация
Такое разделение имеет несколько преимуществ. Во-первых, структура остается четкой. Вы всегда знаете, где хранится определенный контент. Во-вторых, запросы можно контролировать более конкретно. Одни вопросы могут искать только в архиве статей, другие - во всей системе знаний. Пример:
- Исследовательский вопрос можно найти только в архиве статей.
- Стратегический вопрос, с другой стороны, может учитывать все коллекции одновременно.
Такие структуры делают большие системы знаний значительно более эффективными.
Автоматические обновления
Еще один полезный шаг - регулярное обновление системы. В предыдущем примере мы один раз обработали экспорт данных ChatGPT. Однако на практике постоянно создается новый контент.
Новые разговоры, новые заметки, новые документы - вся эта информация также может стать частью вашего архива знаний.
Поэтому стоит подумать об автоматическом обновлении. Одно из простых решений - регулярный импорт новых данных. Например:
- Обрабатывайте новые данные чата раз в неделю
- Автоматический импорт новых документов
- Немедленно добавляйте новые статьи в базу данных
Технически это довольно просто реализовать. Небольшой скрипт может регулярно проверять наличие новых файлов и автоматически обрабатывать их. Это позволит вашей системе знаний постоянно расти. Со временем создается все более обширный архив, документирующий ваши мысли и проекты.
Интеграция в ваши собственные приложения
Пока что наша система используется с помощью простых скриптов на Python. Но в перспективе эту систему можно будет интегрировать и в собственные приложения. Например, многие разработчики создают небольшие веб-интерфейсы, позволяющие напрямую использовать ИИ знаний.
Вместо того чтобы запускать скрипт, можно просто написать вопрос в поле ввода. Этот же процесс выполняется в фоновом режиме:
- Создайте встраивание
- База данных для поиска
- Передача контекста искусственному интеллекту
- Сгенерировать ответ
Результат отображается непосредственно в пользовательском интерфейсе. Такое приложение может принимать самые разные формы. Например:
- персональный исследовательский ИИ
- помощник по знаниям для проектов
- поисковая система идей
- архив статей и заметок
Это становится особенно интересным, когда вы объединяете эти системы с другими инструментами. Например, редакционная система может автоматически обращаться к вашему архиву знаний и использовать предыдущие статьи в качестве основы для исследований. Или система заметок может автоматически интегрировать новые идеи в вашу базу данных.
Другими словами, ИИ становится частью вашей повседневной рабочей среды. Таким образом, становится ясно, что наш небольшой проект выходит далеко за рамки первоначального экспорта данных ChatGPT.
Мы не просто создали архив. Мы создали архитектуру, которую можно расширять по мере необходимости. И именно в этом заключается настоящая ценность таких систем. Они не статичны. Они растут вместе с вашими знаниями.
Расширенная версия трубопровода для загрузки
Следующий сценарий - это расширенная версия конвейера из статьи. Он более надежен и гораздо ближе к продуктивному решению. Улучшены три момента:
- Показатель прогрессаПользователь может в любой момент посмотреть, сколько текстов уже обработано.
- Пакетный импортВкрапления собираются и записываются в Qdrant блоками, что значительно быстрее, чем импорт по отдельности.
- Более быстрый конвейер встраиванияСкрипт работает структурированно с подготовленными фрагментами и сокращает количество ненужных вызовов.
Поэтому этот сценарий особенно удобен, если объем экспорта ChatGPT велик - например, несколько тысяч разговоров. Типичный процесс:
- Загрузить экспорт ChatGPT
- Тексты для извлечения
- Разделите текст на фрагменты
- Создание вкраплений
- Пакетный импорт в Qdrant
- Выполните тестовый запрос
Важные настройки в скрипте
Некоторые значения должны быть настроены пользователем:
- EXPORT_PFAD
Pfad zu den meist nummerierten Dateien conversations.json aus dem ChatGPT-Export. - ИМЯ_КОЛЛЕКЦИИ
Имя коллекции базы данных векторов. - EMBED_MODEL
Embedding-Modell von Ollama, z. B. nomic-embed-text oder mxbai-embed-large - ANSWER_MODEL
Sprachmodell für die Testabfrage, z.B. llama, mistral oder gpt:oss - РАЗМЕР ВЕКТОРА
Размерность модели встраивания.
nomic-embed-text → 768
mxbai-embed-large → 1024 - CHUNK_SIZE
Размер текстовых разделов.
Как правило, 300-600 слов. - РАЗМЕР ПАРТИИ
Сколько вкраплений записывается в Qdrant одновременно.
Типичное значение: 50-200.
Будьте в курсе событий - без рекламы
Wenn Du über Updates zu diesem Skript oder über neue Downloads informiert bleiben möchtest, kannst Du Dich in meinen monatlichen Newsletter eintragen. Der Newsletter ist bewusst schlank gehalten, komplett werbefrei und erscheint nur einmal im Monat. Darin findest Du eine Auswahl der wichtigsten neuen Artikel, praxisnahe Inhalte rund um KI, Software und Digitalisierung sowie Hinweise auf aktualisierte Skripte oder neue Download-Angebote. Kein Spam, keine täglichen Mails – nur die relevantesten Inhalte in kompakter Form. Wenn Du diese Entwicklungen kontinuierlich verfolgen möchtest, ist der Newsletter die einfachste Möglichkeit, auf dem aktuellen Stand zu bleiben.
Ausblick auf Teil 3: Feinschliff, Analyse und optimale Nutzung der Daten
Im dritten Teil der Serie gehen wir einen Schritt weiter und schauen uns an, was sich konkret aus der aufgebauten Wissensdatenbank herausholen lässt. Nachdem die ChatGPT-Daten nun in Qdrant gespeichert sind, steht die eigentliche Nutzung im Mittelpunkt. Wir werfen einen Blick auf die Qdrant-Weboberfläche, analysieren die gespeicherten Daten und prüfen, wie gut die semantische Suche bereits funktioniert. Darüber hinaus geht es um wichtige Feinjustierungen: Wie sollte das Chunking je nach Anwendungsfall gewählt werden? Wie lässt sich der Kontext optimal an ein lokales Sprachmodell übergeben? Und wie kann man die Qualität der Antworten gezielt verbessern? Der dritte Teil richtet sich an alle, die aus dem System mehr herausholen und es bewusst weiterentwickeln möchten.
Часто задаваемые вопросы
- Какой смысл интегрировать экспорт данных ChatGPT в мой собственный ИИ?
Самое большое преимущество заключается в том, что вы можете использовать свои собственные разговоры и мысли в долгосрочной перспективе. Многие люди ведут интенсивные беседы с системами искусственного интеллекта о проектах, идеях, анализе или личных проблемах. Этот контент обычно исчезает в процессе работы платформы. Однако если вы экспортируете его и интегрируете в свою собственную базу знаний, он станет личным архивом. Ваш локальный ИИ сможет обращаться к этому контенту, распознавать взаимосвязи и помогать вам в решении новых вопросов. Вместо того чтобы постоянно начинать с нуля, вы шаг за шагом развиваете собственное мышление. - Разве это не очень сложно для человека, не являющегося разработчиком?
На первый взгляд, такие термины, как вкрапления, векторные базы данных или системы RAG, кажутся сложными. На практике, однако, отдельные этапы довольно четко структурированы. В основном вам понадобятся всего три компонента: локальный ИИ (например, через Ollama), векторная база данных, например Qdrant, и небольшой скрипт на Python, обрабатывающий ваши данные. Многие шаги выполняются автоматически. После настройки система работает как обычная поисковая система или чатбот - за исключением того, что она работает с вашими собственными знаниями. - Какие данные на самом деле содержит экспорт ChatGPT?
Экспорт ChatGPT обычно содержит все разговоры, которые вы вели с системой. Сюда входят не только сами текстовые сообщения, но и метаданные, такие как заголовки бесед, временные метки и структурная информация. Данные обычно доступны в формате JSON и поэтому могут быть относительно легко обработаны с помощью скриптов. Во многих случаях экспорт также включает медиа- или языковые файлы, если они использовались в разговоре. Однако при создании базы знаний интерес представляет в первую очередь текстовый контент. - Почему для таких систем используется векторная, а не обычная база данных?
Обычные базы данных идеально подходят для поиска по определенным терминам или идентификаторам. Однако они менее пригодны для семантического поиска. Векторная база данных хранит тексты не только как строки символов, но и как математические векторы, описывающие смысл текста. Это позволяет системе искать сходство в содержании. Например, если вы запрашиваете „идеи для статей по искусственному интеллекту“, база данных может найти контент, содержащий другие фразы, такие как „темы для статей в блогах по искусственному интеллекту“. - Что такое вкрапления и почему они так важны?
Вкрапления - это математические представления текстов. Языковая модель преобразует текст в список чисел, которые описывают смысл текста. Тексты с похожими значениями лежат близко друг к другу в математическом пространстве. Это позволяет впоследствии искать в векторной базе данных схожий контент. Без вкраплений семантический поиск вряд ли был бы возможен. Они лежат в основе современных RAG-систем и являются причиной того, что такие системы гораздо более гибкие, чем классический полнотекстовый поиск. - Какого размера может быть мой экспорт данных ChatGPT?
Размер не играет особой роли. Даже несколько тысяч разговоров могут быть обработаны без проблем. Важнее количество генерируемых фрагментов текста, так называемых чанков. При большем экспорте получается больше фрагментов и, соответственно, больше вкраплений. Однако современные векторные базы данных легко справляются с миллионами таких записей. Даже небольшого сервера или мощного настольного компьютера вполне достаточно для частного помощника по знаниям. - Почему перед обработкой текст делится на небольшие части?
Если сохранять полные разговоры или большие тексты непосредственно в виде вкраплений, семантический поиск станет неточным. Один текст может содержать несколько тем. Разбив его на небольшие разделы, система впоследствии сможет осуществлять поиск гораздо точнее. Каждый раздел описывает более четкую тему. Это позволяет базе данных находить именно те фрагменты разговора, которые действительно соответствуют текущему вопросу. - Какую роль играет Ollama в этой системе?
Ollama служит локальной платформой для языковых моделей. Она позволяет запускать модели искусственного интеллекта непосредственно на вашем компьютере. В нашей системе Ollama выполняет две задачи: Он создает вкрапления для текстов и генерирует ответы на вопросы. Преимуществом является то, что все данные остаются локальными. Это значит, что ваши разговоры и архив знаний никогда не покинут ваш компьютер. - Почему Qdrant используется в качестве базы данных векторов?
Qdrant - это современная векторная база данных, которая была специально разработана для приложений искусственного интеллекта. Она быстрая, легко installieren и очень хорошо документирована. Кроме того, ее можно легко подключить к Python и многим фреймворкам ИИ. Поэтому Qdrant является особенно практичным решением для локальных систем знаний. Альтернативы включают Chroma, Weaviate или Pinecone. - Что означает термин "система RAG"?
RAG расшифровывается как „Retrieval-Augmented Generation“. Это архитектура, в которой ИИ сначала извлекает релевантную информацию из базы данных, а затем использует ее для генерации ответа. Таким образом, ИИ комбинирует свои собственные знания с внешними данными. Это позволяет ему давать очень точные ответы и в то же время получать доступ к текущей или личной информации. - Можно ли интегрировать в эту систему другие источники данных?
На самом деле, это одно из самых больших преимуществ данной архитектуры. Система не ограничивается данными ChatGPT. Вы также можете интегрировать свои собственные статьи, заметки, PDF-файлы, исследовательские работы или другие документы. Если содержимое может быть обработано в текстовом виде, оно может стать частью базы знаний. Со временем ваша система превратится во всеобъемлющий архив знаний. - Насколько актуальной остается такая система знаний?
Актуальность зависит от того, как часто вы импортируете новые данные. Например, вы можете регулярно обрабатывать новые экспортированные данные из ChatGPT или создать сценарий, который будет автоматически распознавать новые документы. Многие системы настроены на обновление раз в неделю или раз в месяц. Это позволяет постоянно поддерживать базу знаний в актуальном состоянии. - Какое оборудование необходимо для такой системы?
Для небольших проектов достаточно современного настольного компьютера. Если вы хотите использовать большую языковую модель, вам пригодится графический процессор. Однако многие пользователи успешно работают со своими системами знаний и на мощных ноутбуках или мини-серверах. Прежде всего, важно иметь достаточный объем памяти и достаточное пространство для хранения базы данных. - Как быстро работает такая система на практике?
Скорость зависит от нескольких факторов, например, от размера базы данных, аппаратного обеспечения и используемой языковой модели. Во многих случаях запрос занимает всего несколько секунд. Сам векторный поиск обычно выполняется очень быстро. Наибольшая часть времени часто тратится на генерацию ответа от языковой модели. - Можно ли разделить несколько областей знаний?
Да, векторные базы данных, такие как Qdrant, позволяют использовать несколько коллекций. Каждая коллекция может представлять отдельную тематическую область. Например, можно создать коллекцию для разговоров в ChatGPT, одну для статей и одну для заметок. Это позволяет четко структурировать области знаний и осуществлять целенаправленный поиск. - Насколько безопасны мои данные в локальной системе искусственного интеллекта?
Большое преимущество локальной системы заключается в том, что ваши данные не нужно передавать во внешние службы. Вся информация остается на вашем собственном компьютере или сервере. Это особенно важно для конфиденциального контента. Конечно, вам все равно следует регулярно создавать резервные копии и защищать систему от несанкционированного доступа. - Могу ли я также интегрировать эту систему в свои собственные приложения?
Да, к большинству компонентов можно получить доступ через интерфейсы программирования. Это позволяет интегрировать систему знаний в ваши собственные инструменты, например, в веб-интерфейс, редакционную систему или приложение для заметок. Многие разработчики создают небольшие приложения, которые обеспечивают прямой доступ к базе знаний через интерфейс чата. - Как эта технология может развиваться в будущем?
ИИ для личных знаний, вероятно, находится только в самом начале своего развития. В будущем такие системы смогут автоматически интегрировать новый контент, создавать резюме или даже давать собственные предложения по проектам. Чем больше данных поступает в такую систему, тем более ценной она становится. В долгосрочной перспективе она может превратиться в своего рода персональную цифровую память, которая структурирует ваши знания и делает их доступными в любое время.
