Создайте альтернативу Langchain с нуля, используя OceanBase

Создайте альтернативу Langchain с помощью OceanBase.

Недавно я изучал мир OceanBase, распределенной системы управления реляционными базами данных. Просматривая его обширную документацию, я осознал масштаб задачи – объем контента затруднял быстрый и эффективный поиск точной информации.

Это вдохновило меня на идею. Что, если бы был способ упростить этот процесс? Что, если бы мы могли использовать силу искусственного интеллекта для навигации по этому огромному морю информации? Так возникла концепция документального чатбота для OceanBase.

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

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

Короче говоря:

  • Проект интегрирует искусственный интеллект с OceanBase для создания документационного чатбота, способного отвечать на запросы пользователей на основе документации OceanBase и любой другой документации, размещенной на GitHub.
  • Вопросы пользователей и статьи документации преобразуются в векторные представления для сравнения и генерации ответов.
  • Из-за отсутствия встроенной поддержки векторного типа данных в OceanBase, векторы хранятся и извлекаются в виде JSON.
  • Погрузитесь в пошаговое руководство по настройке окружения проекта, тренировке модели и настройке сервера.
  • Проект подчеркивает необходимость включения в OceanBase поддержки векторного типа данных для полной реализации потенциала искусственного интеллекта и машинного обучения.

Некоторые размышления о проекте

Проект по интеграции OceanBase с искусственным интеллектом был сложным, но в то же время интересным начинанием. Это была возможность погрузиться в тонкости искусственного интеллекта и баз данных, что обеспечило обширный опыт обучения.

Обычно документальный чатбот, который мы хотим создать, использует искусственный интеллект для ответа на запросы пользователей с помощью информации из базы данных документов. Он преобразует вопросы пользователей в векторные представления и сравнивает их с предварительно обработанными векторами документов. Самый релевантный документ определяется на основе сходства векторов. Затем чатбот использует этот документ для генерации ответа, обеспечивая точные и соответствующие ответы.

Прежде чем чатбот сможет отвечать на вопросы на основе предоставленной документации, его нужно “обучить” соответствующими знаниями. Процесс обучения, в своей сущности, заключается в преобразовании статей в документации в эмбеддинги – числовые представления (векторы) текста, которые отражают семантические значения слов. Эмбеддинги затем хранятся в базе данных, в данном проекте – OceanBase.

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

Langchain предполагает, что база данных может обрабатывать хранение векторов и выполнение поиска похожих элементов. Однако OceanBase, база данных, которую мы использовали, не поддерживает векторный тип данных напрямую.

Более того, основная цель проекта заключалась в исследовании потенциала OceanBase в качестве векторной базы данных для обучения искусственного интеллекта. Использование Langchain, который самостоятельно обрабатывает поиск похожих элементов, пропустило бы возможность погрузиться в эти аспекты OceanBase.

Поскольку OceanBase не поддерживает векторные хранилища напрямую, нам приходится искать обходное решение. Но векторы в основном представляют собой массивы чисел. Мы можем хранить их в виде строки JSON или BLOB в базе данных. И когда нам нужно сравнивать записи с вопросами векторных представлений, мы можем просто преобразовать их обратно в эмбеддинги на следующем этапе.

Учитывая, что OceanBase не поддерживает векторный тип данных напрямую, каждый эмбеддинг должен быть преобразован в тип данных, поддерживаемый OceanBase, в данном случае – JSON. Следовательно, при сравнении вопроса с статьями, эти записи должны быть преобразованы обратно в исходную форму эмбеддинга. Этот процесс преобразования, к сожалению, приводит к более медленной системе, которая не обладает масштабируемостью.

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

Проект

Система создана на основе фреймворка Node.js с использованием Express.js для обработки HTTP-запросов. Sequelize, обещающий Node.js ORM, используется для выполнения миграций схемы базы данных, заполнения данных и выполнения запросов.

Проект структурирован для обработки двух основных запросов: обучение модели на основе статей и задание вопросов. Конечная точка '/train' извлекает статьи, преобразует их в векторы и сохраняет их в базе данных. Конечная точка '/ask' принимает вопрос пользователя, находит наиболее релевантную статью, используя сохраненные векторы, и генерирует ответ с помощью API OpenAI.

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

Начало работы

Для настройки среды проекта с нуля выполните следующие шаги:

Установите Node.js: Если он еще не установлен, загрузите и установите Node.js с официального веб-сайта Node.js.

Создайте новый проект: Откройте терминал, перейдите в нужный каталог и создайте новый проект с помощью команды mkdir oceanbase-vector. Перейдите в новый каталог проекта с помощью команды cd oceanbase-vector.

Инициализируйте проект: Инициализируйте новый проект Node.js, запустив команду npm init -y. Эта команда создаст новый файл package.json со значениями по умолчанию.

Установите зависимости: Установите необходимые зависимости для проекта. Используйте следующую команду для установки всех необходимых пакетов:

npm install dotenv express lodash mysql2 openai sequelize --save

Мы будем использовать Sequelize в качестве ORM для взаимодействия с базой данных OceanBase. Пакет lodash используется для расчета косинусного сходства в процессе поиска похожих элементов. И, конечно же, нам нужен пакет openai, чтобы взаимодействовать с API OpenAI. Мы будем использовать express в качестве сервера, который предоставит конечные точки ask и train.

Затем используйте npm install sequelize-cli --save-dev, чтобы установить зависимости разработки.

Теперь настройка проекта завершена, и мы готовы начать создавать каждый модуль.

Настройка OceanBase

Для настройки проекта вам сначала нужен работающий кластер OceanBase. В этой статье я написал подробные инструкции по установке OceanBase.

После того как у вас есть работающий экземпляр OceanBase, следующим шагом будет создание таблицы для хранения статей и их соответствующих векторных представлений. Эта таблица, названная article_vectors, будет иметь следующие столбцы:

  • id: Это столбец типа целого числа, который будет служить первичным ключом для таблицы. Он автоматически инкрементируется, что означает, что каждая новая запись будет автоматически получать идентификатор, больший на единицу, чем идентификатор предыдущей записи.
  • content_vector: Это столбец типа JSON, который будет хранить векторное представление статьи. Каждый вектор будет преобразован в объект JSON для хранения.
  • content: Это столбец типа текст, который будет хранить фактическое содержимое статьи.

Для создания таблицы article_vectors можно использовать следующую SQL-команду:

CREATE TABLE article_vectors (
    id INT AUTO_INCREMENT,
    content_vector JSON,
    content TEXT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci,
    PRIMARY KEY (id)
);

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

Нам также необходимо определить модель ArticleVector в проекте Sequlize. Сначала запустите sequelize init, чтобы инициализировать среду Sequlize. В сгенерированной папке /models создайте новый файл с названием ArticleVector.js.

const { DataTypes, Model } = require('sequelize');

class ArticleVector extends Model {}

module.exports = (sequelize) => {
    ArticleVector.init(
        {
            id: {
                type: DataTypes.INTEGER,
                autoIncrement: true,
                primaryKey: true,
            },
            content_vector: {
                type: DataTypes.JSON,
            },
            content: {
                type: DataTypes.TEXT,
            },
        },
        {
            sequelize,
            modelName: 'ArticleVector',
            tableName: 'article_vectors',
            timestamps: false,
        },
        {
            sequelize,
            modelName: 'ArticleVector',
            tableName: 'content',
            timestamps: false,
        }
    );

    return ArticleVector;
};

Код определяет модель Sequelize для таблицы article_vectors в нашей базе данных OceanBase. Sequelize – это ORM на основе обещаний для Node.js, который позволяет взаимодействовать с вашей SQL-базой данных с помощью высокоуровневых вызовов API.

Обучение на документации

Процесс обучения является основой нашего чат-бота по документации. Он включает получение документации OceanBase из репозитория GitHub, преобразование содержимого в векторные представления и сохранение этих векторов в базе данных OceanBase. Этот процесс обрабатывается двумя основными скриптами: trainDocs.js и embedding.js.

Получение документации

Скрипт trainDocs.js получает содержимое документации OceanBase из репозитория GitHub. Он использует API GitHub для доступа к репозиторию и извлечения всех файлов .md. Скрипт рекурсивно получает содержимое каталогов, чтобы гарантировать получение всех файлов документации, независимо от их расположения в репозитории.

Скрипт также получает содержимое каждого файла документации. Он отправляет запрос по URL загрузки файла и сохраняет возвращенное содержимое для дальнейшей обработки.

async function fetchRepoContents(
    repo,
    path = '',
    branch = 'main',
    limit = 100
) {
    const url = `https://api.github.com/repos/${repo}/contents/${path}?ref=${branch}`;
    const accessToken = process.env.GITHUB_TOKEN;
    const response = await fetch(url, {
        headers: {
            Authorization: `Bearer ${accessToken}`,
            Accept: 'application/vnd.github+json',
            'X-GitHub-Api-Version': '2022-11-28',
        },
    });
    const data = await response.json();

    // Если путь - это каталог, рекурсивно получаем содержимое
    if (Array.isArray(data)) {
        let count = 0;
        const files = [];
        for (const item of data) {
            if (count >= limit) {
                break;
            }
            if (item.type === 'dir') {
                const dirFiles = await fetchRepoContents(
                    repo,
                    item.path,
                    branch,
                    limit - count
                );
                files.push(...dirFiles);
                count += dirFiles.length;
            } else if (item.type === 'file' && item.name.endsWith('.md')) {
                files.push(item);
                count++;
            }
        }
        return files;
    }

    return [];
}

/**
 * @param {RequestInfo | URL} url
 */
async function fetchFileContent(url) {
    const response = await fetch(url);
    const content = await response.text();
    return content;
}

Теперь мы можем написать основную функцию для обработки встраивания. Функция будет использовать определенные нами функции получения GitHub для получения всех файлов в формате markdown из заданного репозитория. Обратите внимание, что я добавил параметр limit для ограничения количества получаемых файлов. Это связано с ограничениями API GitHub на количество запросов, которые можно сделать в час. Если в репозитории содержится тысячи файлов, вы можете достичь лимита.

async function articleEmbedding(repo, path = '', branch, limit) {
    const contents = await fetchRepoContents(repo, path, branch, limit);
    console.log(contents.length);
    contents.forEach(async (item) => {
        const content = await fetchFileContent(item.download_url);
        await storeEmbedding(content);
    });
}

Преобразование и сохранение векторов

Скрипт embedding.js отвечает за преобразование полученной документации в векторные представления и сохранение этих векторов в базе данных OceanBase. Для этого используются две основные функции: embedArticle() и storeEmbedding().

Для работы с Sequelize и OpenAI нам нужно их инициализировать.

const { Sequelize } = require('sequelize');
const dotenv = require('dotenv');
dotenv.config();
const env = process.env.NODE_ENV || 'development';
const config = require(__dirname + '/../config/config.json')[env];

const { Configuration, OpenAIApi } = require('openai');

const configuration = new Configuration({
    apiKey: process.env.OPENAI_KEY,
});
const openai = new OpenAIApi(configuration);

Функция embedArticle() использует API встраивания OpenAI для преобразования содержимого статьи в вектор. Она отправляет запрос к API с содержимым статьи и получает сгенерированный вектор.

async function embedArticle(article) {
    // Создаем векторы статьи с помощью OpenAI
    try {
        const result = await openai.createEmbedding({
            model: 'text-embedding-ada-002',
            input: article,
        });
        // получаем вектор
        const embedding = result.data.data[0].embedding;
        return embedding;
    } catch (error) {
        if (error.response) {
            console.log(error.response.status);
            console.log(error.response.data);
        } else {
            console.log(error.message);
        }
    }
}

Функция storeEmbedding() принимает сгенерированный вектор и сохраняет его в базе данных OceanBase. Она подключается к базе данных с помощью Sequelize, создает новую запись в таблице article_vectors и сохраняет вектор и исходное содержимое статьи в соответствующие столбцы.

let sequelize;
if (config.use_env_variable) {
    sequelize = new Sequelize(process.env[config.use_env_variable], config);
} else {
    sequelize = new Sequelize(
        config.database,
        config.username,
        config.password,
        config
    );
}
const ArticleVectorModel = require('../models/ArticleVector');
const ArticleVector = ArticleVectorModel(sequelize);
async function storeEmbedding(article) {
    try {
        await sequelize.authenticate();
        console.log('Соединение успешно установлено.');
        const articleVector = await ArticleVector.create({
            content_vector: await embedArticle(article),
            content: article,
        });
        console.log('Создан новый вектор статьи:', articleVector.id);
    } catch (err) {
        console.error('Ошибка:', err);
    }
}

Чтобы начать процесс обучения, вам просто нужно вызвать функцию articleEmbedding() в файле trainDocs.js с соответствующими параметрами. Эта функция получает документацию, преобразует ее в векторы и сохраняет эти векторы в базе данных.

Этот процесс обучения обеспечивает качественное понимание документации OceanBase чат-ботом, что позволяет ему предоставлять точные и актуальные ответы на запросы пользователей.

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

Как вы могли заметить, мы используем файл .env для хранения конфиденциальной информации в проекте. Вот пример файла .env, который вы можете использовать:

GITHUB_TOKEN="Получите свой токен Github с сайта https://docs.github.com/en/rest/guides/getting-started-with-the-rest-api?apiVersion=2022-11-28"
OPENAI_KEY ="ВАШ_КЛЮЧ_OPENAI"
DOC_OWNER="OceanBase, вы можете изменить это на имя другого продукта, чтобы чат-бот знал, с каким продуктом он работает"
MODEL="поддерживаются gpt-4 и gpt-3.5-turbo"

Запрос к документации

После завершения процесса обучения, чат-бот готов отвечать на запросы пользователей. За это отвечает файл /embeddings/askDocs.js, который использует сохраненные векторы для поиска наиболее соответствующей документации для заданного вопроса и затем генерирует ответ с помощью API OpenAI.

Функция getSimilarDoc() в файле askDocs.js отвечает за поиск наиболее соответствующей документации для заданного вопроса. Она начинает с преобразования вопроса в вектор с помощью функции embedArticle() из файла embedding.js.

Затем она извлекает все сохраненные векторы из таблицы article_vectors в базе данных OceanBase. Затем она вычисляет косинусную схожесть между вектором вопроса и каждым сохраненным вектором. Косинусная схожесть – это мера схожести двух векторов, что делает ее идеальной для этой задачи.

async function getSimilarDoc(question) {
    let sequelize;
    if (config.use_env_variable) {
        sequelize = new Sequelize(process.env[config.use_env_variable], config);
    } else {
        sequelize = new Sequelize(
            config.database,
            config.username,
            config.password,
            config
        );
    }
    const ArticleVector = ArticleVectorModel(sequelize);
    // получить все строки в таблице article_vector
    const vectors = await ArticleVector.findAll();
    sequelize.close();
    // console.log(vectors[0]);

    // Вычислить косинусную схожесть для каждого вектора
    const embeddedQuestion = await embedArticle(question);

    // Вычислить косинусную схожесть для каждого вектора
    // Вычислить косинусную схожесть для каждого вектора
    const similarities = vectors.map((vector) => {
        const similarity = cosineSimilarity(
            embeddedQuestion,
            vector.content_vector
        );
        return {
            id: vector.id,
            content: vector.content,
            similarity: similarity,
        };
    });
    const mostSimilarDoc = _.orderBy(similarities, ['similarity'], ['desc'])[0];
    // console.log(mostSimilarDoc);
    return mostSimilarDoc;
}

Функция cosineSimilarity() в файле askDocs.js является важной частью процесса извлечения документации. Она вычисляет косинусную схожесть между двумя векторами, что является мерой их схожести.

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

Функция принимает два вектора в качестве входных данных. Она вычисляет скалярное произведение двух векторов и величину каждого вектора. Затем косинусное сходство вычисляется как скалярное произведение, деленное на произведение двух величин.

function cosineSimilarity(vecA, vecB) {
    const dotProduct = _.sum(_.zipWith(vecA, vecB, (a, b) => a * b));
    const magnitudeA = Math.sqrt(_.sum(_.map(vecA, (a) => Math.pow(a, 2))));
    const magnitudeB = Math.sqrt(_.sum(_.map(vecB, (b) => Math.pow(b, 2))));

    if (magnitudeA === 0 || magnitudeB === 0) {
        return 0;
    }
    return dotProduct / (magnitudeA * magnitudeB);
}

Функция возвращает документацию с наибольшим косинусным сходством с вопросом. Это наиболее релевантная документация для данного вопроса.

С наиболее релевантной документацией определенной, функция askAI() в askDocs.js генерирует ответ на вопрос. Она использует API OpenAI для генерации контекстно соответствующего ответа на основе определенной документации.

Функция отправляет запрос к API с вопросом и соответствующей документацией. API возвращает сгенерированный ответ, который функция затем возвращает.

Этот процесс гарантирует, что чат-бот предоставляет точные и релевантные ответы на запросы пользователей, делая его ценным инструментом для всех, кто ищет информацию в документации OceanBase.

async function askAI(question) {
    const mostSimilarDoc = await getSimilarDoc(question);
    const context = mostSimilarDoc.content;
    try {
        const result = await openai.createChatCompletion({
            model: process.env.MODEL,
            messages: [
                {
                    role: 'system',
                    content: `Вы являетесь ${
                        process.env.DOC_OWNER || 'помощником по документации'
                    }. Вам будет предоставлена статья из справочной документации и вопрос, пожалуйста, ответьте на вопрос на основе предоставленной статьи. Пожалуйста, не выдумывайте ничего.`,
                },
                {
                    role: 'user',
                    content: `Вот статья, связанная с вопросом:\n ${context}\n Ответьте на этот вопрос:\n ${question}`,
                },
            ],
        });
        // получить ответ
        const answer = result.data.choices[0].message.content;
        console.log(answer);
        return {
            answer: answer,
            docId: mostSimilarDoc.id,
        };
    } catch (error) {
        if (error.response) {
            console.log(error.response.status);
            console.log(error.response.data);
        } else {
            console.log(error.message);
        }
    }
}

Настройка API-сервера

Теперь, когда мы настроили функции обучения и запроса, мы можем вызывать их из конечной точки API. Сервер Express.js является основной точкой входа в наше приложение. Он предоставляет две конечные точки, /train и /ask, которые обрабатывают обучение модели и отвечают на запросы пользователей соответственно. Код, описанный здесь, будет находиться в файле index.js.

Сервер инициализируется с использованием Express.js, быстрого, бездоговорочного и минималистичного веб-фреймворка для Node.js. Он настроен для разбора входящих запросов с использованием промежуточного программного обеспечения express.json().

const express = require('express');
const app = express();
const db = require('./models');
app.use(express.json());

Сервер устанавливает соединение с базой данных OceanBase с использованием Sequelize. На экземпляре Sequelize вызывается функция sync(), чтобы убедиться, что все определенные модели синхронизированы с базой данных. Это включает создание необходимых таблиц, если они еще не существуют.

db.sequelize.sync().then((req) => {
    app.listen(3000, () => {
        console.log('Сервер работает на порту 3000...');
    });
});

Конечная точка обучения

Конечная точка /train является маршрутом POST, который запускает процесс обучения. Она ожидает тело запроса, содержащее данные о репозитории GitHub (repo, path, branch и limit). Эти данные передаются функции articleEmbedding(), которая извлекает документацию, преобразует ее в векторы и сохраняет эти векторы в базе данных.

app.post('/train', async (req, res, next) => {
    try {
        await articleEmbedding(
            req.body.repo,
            req.body.path,
            req.body.branch,
            req.body.limit
        );
        res.json({
            status: 'Успех',
            message: 'Документы успешно обучены.',
        });
    } catch (e) {
        next(e); // Передать ошибку в промежуточное программное обеспечение для обработки ошибок
    }
});

Если процесс обучения проходит успешно, конечная точка отвечает сообщением об успехе. Если произошла ошибка во время процесса, она передается в промежуточное программное обеспечение для обработки ошибок.

POST-запрос к конечной точке будет содержать тело запроса вот такого вида:

{
  "repo":"oceanbase/oceanbase-doc",
  "path":"en-US",
  "branch": "V4.1.0",
  "limit": 1000
}

Вы можете изменить репозиторий на другую документацию, размещенную на GitHub. Путь – это папка целевого содержимого. В данном случае я использовал “en-US”, так как я хочу обучить только английскую документацию OceanBase. Параметр “branch” указывает на ветку репозитория. В большинстве случаев вы можете использовать основную ветку или ветку определенной версии. Параметр “limit” используется только в том случае, если в репозитории слишком много файлов, чтобы избежать превышения лимита вашего API GitHub.

Вот как это выглядит, если обучение проходит успешно.

И в базе данных OceanBase мы можем увидеть все записи и их эмбеддинги:

Конечная точка запроса

Конечная точка /ask также является маршрутом POST. Она ожидает тело запроса, содержащее вопрос пользователя. Этот вопрос передается функции askAI(), которая находит наиболее релевантную документацию и генерирует ответ с использованием API OpenAI.

app.post('/ask', async (req, res, next) => {
    try {
        const answer = await askAI(req.body.question);
        res.json({
            status: 'Успех',
            answer: answer.answer,
            docId: answer.docId,
        });
    } catch (e) {
        next(e); // Передать ошибку в промежуточное программное обеспечение для обработки ошибок
    }
});

Конечная точка отвечает сгенерированным ответом и идентификатором наиболее релевантной документации. Это пример успешного запроса.

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

Заключение

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

Чтобы полностью использовать потенциал искусственного интеллекта и машинного обучения, я бы вновь рекомендовал команде OceanBase рассмотреть возможность внедрения поддержки типа данных вектора. Это не только улучшило бы производительность и масштабируемость системы, но и позиционировало OceanBase как передовое решение базы данных в условиях популярности искусственного интеллекта. Я создал задачу в репозитории OceanBase на GitHub для обсуждения этого предложения, вы можете присоединиться к разговору.

Код для этого проекта доступен на GitHub для всех, кто хочет получить доступ и использовать его. Это означает, что вы можете воспользоваться возможностями этого решения на основе искусственного интеллекта не только для OceanBase, но и для любых других наборов документов, которые у вас есть. Не стесняйтесь клонировать репозиторий, изучать код и использовать его в качестве основы для обучения вашего собственного чат-бота для документов с использованием OceanBase. Это отличный способ сделать ваши документы более интерактивными и доступными.

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