Comment créer un chatbot IA avec Milvus et Towhee
Milvus, une base de données vectorielle open-source, est l’épine dorsale parfaite pour toute application d’IA nécessitant des capacités de recherche vectorielle efficaces et évolutives, ce qui en fait un choix remarquable pour la gestion des données de votre chatbot. Towhee est un framework émergent pour les workflows de machine learning qui simplifie le processus de mise en œuvre et d’orchestration de modèles ML complexes. Il rend également le développement de votre application facile à gérer et à comprendre.
Dans ce tutoriel, vous apprendrez à créer un chatbot IA simple avec Python en utilisant Milvus et Towhee. Vous vous concentrerez sur la façon d’ingérer des données non structurées, de les analyser, de les stocker avec des embeddings et de traiter les requêtes.
Configuration de votre environnement
Tout d’abord, créez un environnement virtuel Python pour exécuter votre chatbot.
Voici une session shell sous Linux. Elle crée l’environnement, l’active et met à niveau pip vers la dernière version.
[egoebelbecker@ares milvus_chatbot]$ python -m venv ./chatbot_venv
[egoebelbecker@ares milvus_chatbot]$ source chatbot_venv/bin/activate
(chatbot_venv) [egoebelbecker@ares milvus_chatbot]$ pip install --upgrade pip
Requirement already satisfied: pip in ./chatbot_venv/lib64/python3.11/site-packages (22.2.2)
Collecting pip
Using cached pip-23.1.2-py3-none-any.whl (2.1 MB)
Installing collected packages: pip
Attempting uninstall: pip
Found existing installation: pip 22.2.2
Uninstalling pip-22.2.2:
Successfully uninstalled pip-22.2.2
Successfully installed pip-23.1.2
Ensuite, installez les packages dont vous avez besoin pour exécuter le code : pandas, jupyter, langchain, towhee, unstructured, milvus, pymilvus, sentence_transformers et gradio.
(chatbot_venv) [egoebelbecker@ares milvus_chatbot]$ pip install pandas jupyter langchain towhee unstructured milvus pymilvus sentence_transformers gradio
Collecte de pandas
Obtention des informations de dépendance pour pandas depuis https://files.pythonhosted.org/packages/d0/28/88b81881c056376254618fad622a5e94b5126db8c61157ea1910cd1c040a/pandas-2.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata
Utilisation du cache pandas-2.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (18 kB)
Collecte de jupyter
Utilisation du cache jupyter-1.0.0-py2.py3-none-any.whl (2.7 kB)
(extrait)
Installation des paquets collectés : webencodings, wcwidth, pytz, pure-eval, ptyprocess, pickleshare, json5, ipython-genutils, filetype, fastjsonschema, executing, backcall, zipp, XlsxWriter, xlrd, widgetsnbextension, websocket-client, webcolors, urllib3, uri-template, tzdata, typing-extensions, traitlets, tqdm, tornado, tinycss2, tenacity, tabulate, soupsieve, sniffio, six, send2trash, rpds-py, rfc3986-validator, rfc3986, regex, pyzmq, PyYAML, python-magic, python-json-logger, pypandoc, pygments, pycparser, psutil, prompt-toolkit, prometheus-client, platformdirs, pkginfo, pillow, pexpect, parso, pandocfilters, packaging, overrides, olefile, numpy, nest-asyncio, mypy-extensions, multidict, more-itertools, mistune, mdurl, markupsafe, markdown, lxml, jupyterlab-widgets, jupyterlab-pygments, jsonpointer, joblib, jeepney, idna, greenlet, frozenlist, fqdn, et-xmlfile, docutils, defusedxml, decorator, debugpy, click, charset-normalizer, chardet, certifi, babel, attrs, async-timeout, async-lru, yarl, typing-inspect, terminado, SQLAlchemy, rfc3339-validator, requests, referencing, qtpy, python-pptx, python-docx, python-dateutil, pydantic, pdf2image, openpyxl, numexpr, nltk, msg-parser, matplotlib-inline, marshmallow, markdown-it-py, jupyter-core, jinja2, jedi, jaraco.classes, importlib-metadata, comm, cffi, bleach, beautifulsoup4, asttokens, anyio, aiosignal, stack-data, rich, requests-toolbelt, readme-renderer, pandas, openapi-schema-pydantic, langsmith, jupyter-server-terminals, jupyter-client, jsonschema-specifications, dataclasses-json, cryptography, arrow, argon2-cffi-bindings, aiohttp, SecretStorage, pdfminer.six, langchain, jsonschema, isoduration, ipython, argon2-cffi, unstructured, nbformat, keyring, ipykernel, twine, qtconsole, nbclient, jupyter-events, jupyter-console, ipywidgets, towhee, nbconvert, jupyter-server, notebook-shim, jupyterlab-server, jupyter-lsp, jupyterlab, notebook, jupyter
Installation réussie de PyYAML-6.0.1 SQLAlchemy-2.0.19 SecretStorage-3.3.3 XlsxWriter-3.1.2 aiohttp-3.8.5 aiosignal-1.3.1 anyio-3.7.1 argon2-cffi-21.3.0 argon2-cffi-bindings-21.2.0 arrow-1.2.3 asttokens-2.2.1 async-lru-2.0.4 async-timeout-4.0.2 attrs-23.1.0 babel-2.12.1 backcall-0.2.0 beautifulsoup4-4.12.2 bleach-6.0.0 certifi-2023.7.22 cffi-1.15.1 chardet-5.1.0 charset-normalizer-3.2.0 click-8.1.6 comm-0.1.3 cryptography-41.0.2 dataclasses-json-0.5.14 debugpy-1.6.7 decorator-5.1.1 defusedxml-0.7.1 docutils-0.20.1 et-xmlfile-1.1.0 executing-1.2.0 fastjsonschema-2.18.0 filetype-1.2.0 fqdn-1.5.1 frozenlist-1.4.0 greenlet-2.0.2 idna-3.4 importlib-metadata-6.8.0 ipykernel-6.25.0 ipython-8.14.0 ipython-genutils-0.2.0 ipywidgets-8.0.7 isoduration-20.11.0 jaraco.classes-3.3.0 jedi-0.19.0 jeepney-0.8.0 jinja2-3.1.2 joblib-1.3.1 json5-0.9.14 jsonpointer-2.4 jsonschema-4.18.4 jsonschema-specifications-2023.7.1 jupyter-1.0.0 jupyter-client-8.3.0 jupyter-console-6.6.3 jupyter-core-5.3.1 jupyter-events-0.7.0 jupyter-lsp-2.2.0 jupyter-server-2.7.0 jupyter-server-terminals-0.4.4 jupyterlab-4.0.3 jupyterlab-pygments-0.2.2 jupyterlab-server-2.24.0 jupyterlab-widgets-3.0.8 keyring-24.2.0 langchain-0.0.248 langsmith-0.0.15 lxml-4.9.3 markdown-3.4.4 markdown-it-py-3.0.0 markupsafe-2.1.3 marshmallow-3.20.1 matplotlib-inline-0.1.6 mdurl-0.1.2 mistune-3.0.1 more-itertools-10.0.0 msg-parser-1.2.0 multidict-6.0.4 mypy-extensions-1.0.0 nbclient-0.8.0 nbconvert-7.7.3 nbformat-5.9.2 nest-asyncio-1.5.7 nltk-3.8.1 notebook-7.0.1 notebook-shim-0.2.3 numexpr-2.8.4 numpy-1.25.2 olefile-0.46 openapi-schema-pydantic-1.2.4 openpyxl-3.1.2 overrides-7.3.1 packaging-23.1 pandas-2.0.3 pandocfilters-1.5.0 parso-0.8.3 pdf2image-1.16.3 pdfminer.six-20221105 pexpect-4.8.0 pickleshare-0.7.5 pillow-10.0.0 pkginfo-1.9.6 platformdirs-3.10.0 prometheus-client-0.17.1 prompt-toolkit-3.0.39 psutil-5.9.5 ptyprocess-0.7.0 pure-eval-0.2.2 pycparser-2.21 pydantic-1.10.12 pygments-2.15.1 pypandoc-1.11 python-dateutil-2.8.2 python-docx-0.8.11 python-json-logger-2.0.7 python-magic-0.4.27 python-pptx-0.6.21 pytz-2023.3 pyzmq-25.1.0 qtconsole-5.4.3 qtpy-2.3.1 readme-renderer-40.0 referencing-0.30.0 regex-2023.6.3 requests-2.31.0 requests-toolbelt-1.0.0 rfc3339-validator-0.1.4 rfc3986-2.0.0 rfc3986-validator-0.1.1 rich-13.5.1 rpds-py-0.9.2 send2trash-1.8.2 six-1.16.0 sniffio-1.3.0 soupsieve-2.4.1 stack-data-0.6.2 tabulate-0.9.0 tenacity-8.2.2 terminado-0.17.1 tinycss2-1.2.1 tornado-6.3.2 towhee-1.1.1 tqdm-4.65.0 traitlets-5.9.0 twine-4.0.2 typing-extensions-4.7.1 typing-inspect-0.9.0 tzdata-2023.3 unstructured-0.8.7 uri-template-1.3.0 urllib3-2.0.4 wcwidth-0.2.6 webcolors-1.13 webencodings-0.5.1 websocket-client-1.6.1 widgetsnbextension-4.0.8 xlrd-2.0.1 yarl-1.9.2 zipp-3.16.2
(chatbot_venv) [egoebelbecker@ares milvus_chatbot]$
Vous pouvez trouver un notebook Jupyter avec le code de ce tutoriel ici. Téléchargez-le, lancez Jupyter et chargez le notebook :
chatbot_venv) [egoebelbecker@ares milvus_chatbot]$ jupyter notebook milvus_chatbot.ipynb
[I 2023-07-31 11:29:01.748 ServerApp] Package notebook took 0.0000s to import
[I 2023-07-31 11:29:01.759 ServerApp] Package jupyter_lsp took 0.0108s to import
[W 2023-07-31 11:29:01.759 ServerApp] A `_jupyter_server_extension_points` function was not found in jupyter_lsp. Instead, a `_jupyter_server_extension_paths` function was found and will be used for now. This function name will be deprecated in future releases of Jupyter Server.
[I 2023-07-31 11:29:01.764 ServerApp] Package jupyter_server_terminals took 0.0045s to import
[I 2023-07-31 11:29:01.765 ServerApp] Package jupyterlab took 0.0000s to import
[I 2023-07-31 11:29:02.124 ServerApp] Package notebook_shim took 0.0000s to import
Créer un chatbot
Maintenant, passons au chatbot.
Magasin de documents
Le bot doit stocker des fragments de documents, ainsi que les embeddings que Towhee en extrait. C’est pour cela que vous utiliserez Milvus. Vous avez déjà installé Milvus Lite, une version légère de Milvus, ci-dessus avec la bibliothèque milvus.
Vous pouvez exécuter un serveur depuis la ligne de commande :
(chatbot_venv) [egoebelbecker@ares milvus_chatbot]$ milvus-server
__ _________ _ ____ ______
/ |/ / _/ /| | / / / / / __/
/ /|_/ // // /_| |/ / /_/ /\ \
/_/ /_/___/____/___/\____/___/ {Lite}
Welcome to use Milvus!
Version: v2.2.12-lite
Process: 139309
Started: 2023-07-31 12:43:43
Config: /home/egoebelbecker/.milvus.io/milvus-server/2.2.12/configs/milvus.yaml
Logs: /home/egoebelbecker/.milvus.io/milvus-server/2.2.12/logs
Ctrl+C to exit …
Ou, dans le cadre du code de votre application, comme indiqué dans le notebook :
from milvus import default_server
# Start Milvus service
default_server.start()
# # Stop Milvus service
# default_server.stop()
Définir les variables de l’application et obtenir la clé API OpenAI
Ensuite, définissez quelques variables et nettoyez tous les fichiers SQLite restants. Nous utiliserons SQLite ci-dessous pour l’historique de discussion.
- MILVUS_URI - les informations de connexion pour les serveurs Milvus. Analysées en hôte et port.
- MILVUS_HOST - l’hôte sur lequel Milvus s’exécute.
- MILVUS_PORT - le port sur lequel le serveur écoute.
- DROP_EXIST - supprimer les collections Milvus existantes au démarrage.
- EMBED_MODEL - le modèle sentence_transformers que le code utilisera pour créer des embeddings
- COLLECTION_NAME - nom de la collection Milvus pour les données et les embeddings
- DIM - la dimension des embeddings que le modèle crée pour chaque morceau de texte
- OPENAI_API_KEY - clé pour l’API LLM
import getpass
import os
MILVUS_URI = 'http://localhost:19530'
[MILVUS_HOST, MILVUS_PORT] = MILVUS_URI.split('://')[1].split(':')
DROP_EXIST = True
EMBED_MODEL = 'all-mpnet-base-v2'
COLLECTION_NAME = 'chatbot_demo'
DIM = 768
OPENAI_API_KEY = getpass.getpass('Enter your OpenAI API key: ')
if os.path.exists('./sqlite.db'):
os.remove('./sqlite.db')
Exécutez ce code pour définir les variables et répondez à l’invite pour la clé API.
Exemple de pipeline
Ensuite, il est temps de télécharger des données et de les stocker dans Milvus. Mais avant cela, examinons un exemple de pipeline pour télécharger et traiter des données non structurées.
Vous utiliserez les pages de documentation Towhee pour cet exemple. Vous pouvez essayer différents sites pour voir comment le code traite différents jeux de données.
Ce code utilise des pipelines Towhee :
- input - commence un nouveau pipeline avec la source qui lui est transmise
- map - utilise ops.text_loader() pour récupérer l’URL et la mapper vers 'doc'
- flat_map - utilise ops.text_splitter() pour traiter le document en « fragments » destinés au stockage
- output - ferme et prépare le pipeline à l’utilisation
Transmettez ce pipeline à DataCollection pour voir comment il fonctionne.
from towhee import pipe, ops, DataCollection
pipe_load = (
pipe.input('source')
.map('source', 'doc', ops.text_loader())
.flat_map('doc', 'doc_chunks', ops.text_splitter(chunk_size=300))
.output('source', 'doc_chunks')
)
DataCollection(pipe_load('https://towhee.io')).show()
Voici la sortie de show() :
Le pipeline a créé cinq morceaux à partir du document.
Exemple de pipeline d’embedding
Le pipeline a récupéré les données et créé des morceaux. Vous devez également créer des embeddings. Examinons un autre exemple de pipeline.
Celui-ci utilise map() pour exécuter ops.sentence_embedding.sbert() sur chaque morceau. Dans cet exemple, nous transmettons un seul bloc de texte.
pipe_embed = (
pipe.input('doc_chunk')
.map('doc_chunk', 'vec', ops.sentence_embedding.sbert(model_name=EMBED_MODEL))
.map('vec', 'vec', ops.np_normalize())
.output('doc_chunk', 'vec')
)
text = '''SOTA Models
We provide 700+ pre-trained embedding models spanning 5 fields (CV, NLP, Multimodal, Audio, Medical), 15 tasks, and 140+ model architectures.
These include BERT, CLIP, ViT, SwinTransformer, data2vec, etc.
'''
DataCollection(pipe_embed(text)).show()
Exécutez ce code pour voir comment le pipeline traite le bloc de texte unique.
Préparer Milvus
Maintenant, vous avez besoin d’une collection pour contenir les données. Ce bloc définit create_collection(), qui utilise MILVUS_HOST et MILVUS_PORT pour se connecter à Milvus, supprimer toute collection existante portant le nom spécifié, et en créer une nouvelle avec ce schéma :
- id - un identifiant entier
- embedding - un vecteur de nombres flottants pour les embeddings
- text - le texte correspondant aux embeddings
from pymilvus import (
connections, utility, Collection,
CollectionSchema, FieldSchema, DataType
)
def create_collection(collection_name):
connections.connect(host=MILVUS_HOST, port=MILVUS_PORT)
has_collection = utility.has_collection(collection_name)
if has_collection:
collection = Collection(collection_name)
if DROP_EXIST:
collection.drop()
else:
return collection
# Create collection
fields = [
FieldSchema(name='id', dtype=DataType.INT64, is_primary=True, auto_id=True),
FieldSchema(name='embedding', dtype=DataType.FLOAT_VECTOR, dim=DIM),
FieldSchema(name='text', dtype=DataType.VARCHAR, max_length=500)
]
schema = CollectionSchema(
fields=fields,
description="Towhee demo",
enable_dynamic_field=True
)
collection = Collection(name=collection_name, schema=schema)
index_params = {
'metric_type': 'IP',
'index_type': 'IVF_FLAT',
'params': {'nlist': 1024}
}
collection.create_index(
field_name='embedding',
index_params=index_params
)
return collection
Pipeline d’insertion
Il est temps de traiter votre texte d’entrée et de l’insérer dans Milvus. Commençons par un pipeline qui condense ce que vous avez appris ci-dessus.
Cette fonction :
- Crée la nouvelle collection
- Récupère les données
- Les divise en morceaux
- Crée des embeddings en utilisant EMBED_MODEL
- Insère le texte et les embeddings dans Milvus
load_data = (
pipe.input('collection_name', 'source')
.map('collection_name', 'collection', create_collection)
.map('source', 'doc', ops.text_loader())
.flat_map('doc', 'doc_chunk', ops.text_splitter(chunk_size=300))
.map('doc_chunk', 'vec', ops.sentence_embedding.sbert(model_name=EMBED_MODEL))
.map('vec', 'vec', ops.np_normalize())
.map(('collection_name', 'vec', 'doc_chunk'), 'mr',
ops.ann_insert.osschat_milvus(host=MILVUS_HOST, port=MILVUS_PORT))
.output('mr')
)
Le voici en action. Exécutez-le sur la page Wikipédia de Frodo Baggins.
project_name = 'towhee_demo'
data_source = 'https://en.wikipedia.org/wiki/Frodo_Baggins'
mr = load_data(COLLECTION_NAME, data_source)
print('Doc chunks inserted:', len(mr.to_list()))
Cela insère 408 fragments avec des embeddings :
2023-07-31 16:50:53,369 - 139993906521792 - node.py-node:167 - INFO: Begin to run Node-_input
2023-07-31 16:50:53,371 - 139993906521792 - node.py-node:167 - INFO: Begin to run Node-create_collection-0
2023-07-31 16:50:53,373 - 139993881343680 - node.py-node:167 - INFO: Begin to run Node-text-loader-1
2023-07-31 16:50:53,374 - 139993898129088 - node.py-node:167 - INFO: Begin to run Node-text-splitter-2
2023-07-31 16:50:53,376 - 139993872950976 - node.py-node:167 - INFO: Begin to run Node-sentence-embedding/sbert-3
2023-07-31 16:50:53,377 - 139993385268928 - node.py-node:167 - INFO: Begin to run Node-np-normalize-4
2023-07-31 16:50:53,378 - 139993376876224 - node.py-node:167 - INFO: Begin to run Node-ann-insert/osschat-milvus-5
2023-07-31 16:50:53,379 - 139993368483520 - node.py-node:167 - INFO: Begin to run Node-_output
(snip)
Categories:
2023-07-31 18:07:53,530 - 140552729257664 - logger.py-logger:14 - DETAIL: Skipping sentence because does not exceed 5 word tokens
Categories
2023-07-31 18:07:53,532 - 140552729257664 - logger.py-logger:14 - DETAIL: Skipping sentence because does not exceed 3 word tokens
Hidden categories
2023-07-31 18:07:53,533 - 140552729257664 - logger.py-logger:14 - DETAIL: Skipping sentence because does not exceed 3 word tokens
Hidden categories
2023-07-31 18:07:53,533 - 140552729257664 - logger.py-logger:14 - DETAIL: Not narrative. Text does not contain a verb:
Hidden categories:
2023-07-31 18:07:53,534 - 140552729257664 - logger.py-logger:14 - DETAIL: Skipping sentence because does not exceed 5 word tokens
Hidden categories
Doc chunks inserted: 408
Rechercher dans la base de connaissances
Maintenant, avec les embeddings et le texte stockés dans Milvus, vous pouvez effectuer une recherche.
Cette fonction crée un pipeline de requête. L’étape la plus importante est celle-ci :
ops.ann_search.osschat_milvus(host=MILVUS_HOST, port=MILVUS_PORT,
**{'metric_type': 'IP', 'limit': 3, 'output_fields': ['text']}))
osschat_milvus recherche dans les embeddings des correspondances avec le texte soumis.
Voici le pipeline complet :
pipe_search = (
pipe.input('collection_name', 'query')
.map('query', 'query_vec', ops.sentence_embedding.sbert(model_name=EMBED_MODEL))
.map('query_vec', 'query_vec', ops.np_normalize())
.map(('collection_name', 'query_vec'), 'search_res',
ops.ann_search.osschat_milvus(host=MILVUS_HOST, port=MILVUS_PORT,
**{'metric_type': 'IP', 'limit': 3, 'output_fields': ['text']}))
.flat_map('search_res', ('id', 'score', 'text'), lambda x: (x[0], x[1], x[2]))
.output('query', 'text', 'score')
)
Essayez-le :
query = 'Who is Frodo Baggins?'
DataCollection(pipe_search(project_name, query)).show()
Le modèle réussit bien à extraire trois nœuds étroitement correspondants :
Ajouter un LLM
Maintenant, il est temps d’ajouter un grand modèle de langage (LLM) afin que les utilisateurs puissent tenir une conversation avec le chatbot. Nous utiliserons ChatGPT et l’API OpenAI pour cet exemple.
Historique de chat
Afin d’obtenir de meilleurs résultats du LLM, vous devez stocker l’historique de chat et le présenter avec les requêtes. Vous utiliserez SQLite pour cette étape.
Voici une fonction pour récupérer l’historique :
pipe_get_history = (
pipe.input('collection_name', 'session')
.map(('collection_name', 'session'), 'history', ops.chat_message_histories.sql(method='get'))
.output('collection_name', 'session', 'history')
)
Voici celle pour le stocker :
pipe_add_history = (
pipe.input('collection_name', 'session', 'question', 'answer')
.map(('collection_name', 'session', 'question', 'answer'), 'history', ops.chat_message_histories.sql(method='add'))
.output('history')
)
Pipeline de requête LLM
Maintenant, nous avons besoin d’un pipeline pour soumettre des requêtes à ChatGPT.
Ce pipeline :
- recherche dans Milvus à l’aide de la requête de l’utilisateur
- collecte l’historique de chat actuel
- soumet la requête, la recherche Milvus et l’historique de chat à ChatGPT
- Ajoute le résultat de ChatGPT à l’historique de chat
- Renvoie le résultat à l’appelant
chat = (
pipe.input('collection_name', 'query', 'session')
.map('query', 'query_vec', ops.sentence_embedding.sbert(model_name=EMBED_MODEL))
.map('query_vec', 'query_vec', ops.np_normalize())
.map(('collection_name', 'query_vec'), 'search_res',
ops.ann_search.osschat_milvus(host=MILVUS_HOST,
port=MILVUS_PORT,
**{'metric_type': 'IP', 'limit': 3, 'output_fields': ['text']}))
.map('search_res', 'knowledge', lambda y: [x[2] for x in y])
.map(('collection_name', 'session'), 'history', ops.chat_message_histories.sql(method='get'))
.map(('query', 'knowledge', 'history'), 'messages', ops.prompt.question_answer())
.map('messages', 'answer', ops.LLM.OpenAI(api_key=OPENAI_API_KEY,
model_name='gpt-3.5-turbo',
temperature=0.8))
.map(('collection_name', 'session', 'query', 'answer'), 'new_history', ops.chat_message_histories.sql(method='add'))
.output('query', 'history', 'answer', )
)
Testons ce pipeline avant de le connecter à une interface graphique :
new_query = 'Where did Frodo take the ring?'
DataCollection(chat(COLLECTION_NAME, new_query, session_id)).show()
Voici la sortie et les résultats dans le notebook :
Le pipeline fonctionne. Assemblons une interface Gradio.
Interface graphique Gradio
Tout d’abord, vous avez besoin de fonctions pour créer un identifiant de session et pour répondre aux requêtes depuis l’interface.
Ces fonctions créent un ID de session à l’aide d’un UUID, et acceptent une session et une requête pour le pipeline de requête.
import uuid
import io
def create_session_id():
uid = str(uuid.uuid4())
suid = ''.join(uid.split('-'))
return 'sess_' + suid
def respond(session, query):
res = chat(COLLECTION_NAME, query, session).get_dict()
answer = res['answer']
response = res['history']
response.append((query, answer))
return response
Ensuite, l’interface Gradio utilise ces fonctions pour créer un chatbot.
Elle utilise l’API Blocks pour créer une interface ChatBot. Le bouton Send Message utilise la fonction respond pour envoyer des requêtes à ChatGPT.
import gradio as gr
with gr.Blocks() as demo:
session_id = gr.State(create_session_id)
with gr.Row():
with gr.Column(scale=2):
gr.Markdown('''## Chat''')
conversation = gr.Chatbot(label='conversation').style(height=300)
question = gr.Textbox(label='question', value=None)
send_btn = gr.Button('Send Message')
send_btn.click(
fn=respond,
inputs=[
session_id,
question
],
outputs=conversation,
)
demo.launch(server_name='127.0.0.1', server_port=8902)
Le voici :
Maintenant, vous disposez d’un chatbot intelligent basé sur un LLM avec Milvus !
Résumé
Dans cet article, nous avons créé des pipelines Towhee pour ingérer des données non structurées, les traiter pour générer des embeddings et stocker ces embeddings dans Milvus. Ensuite, nous avons créé un pipeline de requête pour la fonction de chat et connecté le chatbot à un LLM. Enfin, nous avons obtenu un chatbot intelligent.
Ce tutoriel montre à quel point il est facile de créer des applications avec Milvus. Milvus apporte de nombreux avantages lorsqu’il est intégré à des applications, en particulier celles qui s’appuient sur l’apprentissage automatique et l’intelligence artificielle. Il offre des capacités de recherche et d’analyse de similarité vectorielle hautement efficaces, évolutives et fiables, essentielles dans des applications comme les chatbots, les systèmes de recommandation et la reconnaissance d’images ou de texte.
Cet article a été rédigé par Eric Goebelbecker. Eric a travaillé sur les marchés financiers à New York pendant 25 ans, développant l’infrastructure pour les données de marché et les réseaux du protocole d’échange d’informations financières (FIX). Il aime parler de ce qui rend les équipes efficaces (ou moins efficaces !).
Continuer à lire
From Vector Database to Vector Lakebase
Zilliz offers a fully managed Vector Lakebase powered by Milvus, unifying real-time vector search, lake-scale discovery, and Al data operations.
Migrating from S3 Vectors to Zilliz Cloud: Unlocking the Power of Tiered Storage
Learn how Zilliz Cloud bridges cost and performance with tiered storage and enterprise-grade features, and how to migrate data from AWS S3 Vectors to Zilliz Cloud.
Building RAG Pipelines for Real-Time Data with Cloudera and Milvus
explore how Cloudera can be integrated with Milvus to effectively implement some of the key functionalities of RAG pipelines.