Créer des applications RAG sans OpenAI - Première partie
OpenAI est le grand modèle de langage (LLM) le plus couramment connu. Mais ce n’est pas le seul LLM. Si vous êtes un lecteur régulier de ce blog, vous savez déjà que nous avons construit de nombreuses applications de type RAG en utilisant LangChain, Milvus et OpenAI. Dans ce projet, nous intégrons Nebula (cliquez sur le site web de Nebula pour demander une clé API) en remplacement d’OpenAI, et nous utilisons un modèle d’embedding de Hugging Face à la place des embeddings d’OpenAI.
Dans cet article, nous aborderons :
Pile technologique RAG conversationnelle
LangChain
Symbl AI
Milvus
Hugging Face
Comment créer une application RAG conversationnelle de base
Configurer votre pile RAG conversationnelle
Créer votre conversation
Poser des questions
Résumé de la création d’un RAG conversationnel sans OpenAI
Pile technologique RAG conversationnelle
Le RAG conversationnel est la forme la plus courante de RAG. C’est ce à quoi nous pensons lorsque nous pensons aux chatbots RAG. L’année dernière, nous avons expliqué comment CVP (LLM de type ChatGPT + base de données vectorielle + prompt as code) constitue la pile canonique pour le RAG. Dans cette pile, nous ajoutons un modèle supplémentaire : un modèle d’embedding distinct de Hugging Face. Cette pile utilise LangChain pour l’orchestration des prompts, Symbl AI pour fournir le LLM, Milvus comme base de données vectorielle et Hugging Face comme modèle d’embedding.
LangChain
Si vous n’en avez pas encore entendu parler, c’est maintenant chose faite : LangChain est le framework d’orchestration d’applications LLM le plus populaire. Ce tutoriel est une adaptation d’un projet que nous avons réalisé en utilisant la mémoire conversationnelle avec LangChain et OpenAI. Nous réalisons le même projet cette fois-ci sans embeddings OpenAI ni GPT.
Symbl AI
Symbl AI a créé un LLM conversationnel entraîné sur des données de conversation. Leur LLM s’appelle Nebula, et il dispose d’une intégration LangChain. Dans ce tutoriel, nous remplaçons le GPT-3.5 d’OpenAI, que nous avions utilisé auparavant, par Nebula.
Milvus
La pièce maîtresse de notre élément de mémoire conversationnelle est une base de données vectorielle. Comme nous l’avons expliqué, les bases de données vectorielles sont conçues pour fonctionner avec des données non structurées une fois transformées en vecteurs. Nous utilisons Milvus comme stockage pour la partie mémoire conversationnelle de ce projet.
Hugging Face
Hugging Face est le plus grand hub de modèles au monde. Ils s’intègrent également directement à LangChain. Nous utilisons un modèle d’embedding de Hugging Face au lieu des embeddings OpenAI que nous avons utilisés dans notre dernier projet.
Comment créer une application RAG conversationnelle de base
Maintenant que nous connaissons la pile technologique :
Il y a un peu de configuration à effectuer.
Nous définissons un exemple de conversation sur lequel l’application effectuera le RAG.
Nous terminons en posant une question d’exemple.
Configurer votre pile RAG conversationnelle
Configurons notre pile RAG conversationnelle. Nous devons installer six bibliothèques : LangChain, Milvus (Lite), PyMilvus, python-dotenv et Sentence Transformers. Dans la première section, nous importons certaines des pièces essentielles de LangChain : les objets Vector Store Retriever Memory, Conversation Chain et Prompt Template. Nous utilisons ces éléments pour créer notre exemple de mémoire conversationnelle.
Deux des autres imports sont `os` et `load_dotenv`. Nous les utilisons pour charger nos variables d’environnement. Si vous vous souvenez d’autres tutoriels que nous avons réalisés, nous chargeons généralement notre clé API OpenAI ; cette fois, nous chargeons la clé API Nebula.
! pip install langchain milvus pymilvus python-dotenv sentence_transformers
from langchain.memory import VectorStoreRetrieverMemory
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate
import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv("NEBULA_KEY")
Ensuite, commençons par notre base de données vectorielle et notre modèle d’embedding. Nous importons le `default_server` depuis Milvus Lite et le démarrons pour notre base de données vectorielle. Ensuite, nous importons les embeddings Hugging Face depuis LangChain et les utilisons comme fonction d’embedding. Le modèle par défaut est `all-mpnet-base-v2`, qui a une dimensionnalité de 768.
from milvus import default_server
default_server.start()
from langchain_community.embeddings import HuggingFaceEmbeddings
# is this model by default: sentence-transformers/all-mpnet-base-v2
embeddings = HuggingFaceEmbeddings()
La section suivante est davantage une section de « nettoyage ». Elle n’est pas pertinente si vous n’avez pas encore utilisé LangChain avec Milvus. Ici, nous nous connectons à Milvus et supprimons la collection LangChain existante afin d’éviter l’empoisonnement des données.
from pymilvus import utility, connections
connections.connect(host="127.0.0.1", port=default_server.listen_port)
utility.drop_collection('LangChainCollection')
Créez votre conversation
Maintenant, il est temps de créer et de stocker notre conversation.
Nous commençons par importer un objet de collection de magasin vectoriel Milvus depuis LangChain et le démarrons avec un ensemble vide de documents. Nous lui transmettons également la fonction d’embeddings Hugging Face que nous avons créée précédemment. Nous transmettons l’hôte et le port de notre instance Milvus Lite pour les arguments de connexion. Le dernier paramètre de cet objet que nous utiliserons cette fois est `consistency_level`, qui définit le niveau de cohérence des données, dans ce cas - « Strong », le niveau de cohérence des données le plus élevé disponible.
from langchain.vectorstores import Milvus
vectordb = Milvus.from_documents(
{},
embeddings,
connection_args={"host": "127.0.0.1", "port": default_server.listen_port},
consistency_level="Strong")
Ensuite, nous allons configurer un récupérateur de magasin vectoriel en utilisant LangChain en transmettant la collection Milvus et les arguments de recherche. Pour cette recherche, nous voulons seulement récupérer le meilleur résultat. Ensuite, nous transmettrons ce récupérateur à un objet de mémoire que nous pouvons utiliser avec des LLM dans le cadre de la pile RAG de LangChain.
Nous avons également besoin d’une conversation d’amorçage. Dans la vraie vie, cette conversation ressemble à un appel au service client. Dans cet exemple, je vais donner quelques informations sur moi-même. Vous devriez lui donner quelques informations sur vous-même. Une fois un exemple de conversation créé, nous devons l’enregistrer dans notre mémoire comme contexte.
Lors de l’enregistrement du contexte, nous transmettons deux dictionnaires à notre objet de mémoire. Pour cet exemple, nous transmettons l’entrée et la sortie d’exemple comme « input » et « output » respectivement. Si vous voulez expérimenter, vous pouvez transmettre ce que vous souhaitez comme clés et valeurs pour la fonction `save_context`.
retriever = Milvus.as_retriever(vectordb, search_kwargs=dict(k=1))
memory = VectorStoreRetrieverMemory(retriever=retriever)
about_me = [
{"input": "My favorite snack is chocolate",
"output": "Nice"},
{"input": "My favorite sport is swimming",
"output": "Cool"},
{"input": "My favorite beer is Guinness",
"output": "Great"},
{"input": "My favorite dessert is cheesecake",
"output": "Good to know"},
{"input": "My favorite musician is Taylor Swift",
"output": "I also love Taylor Swift"}
]
for example in about_me:
memory.save_context({"input": example["input"]}, {"output": example["output"]})
Poser des questions
Tout est maintenant prêt pour que nous posions des questions à notre application RAG conversationnelle. Dans ce cas, elle dispose d’une base de données vectorielle avec la mémoire de notre conversation jusqu’à présent, d’un modèle d’embedding de Hugging Face et d’un LLM non-OpenAI, Nebula. Avant de poser des questions, vérifions rapidement que l’application se souvient de notre conversation.
Demandons-lui de nous montrer s’il se souvient de quelque chose de la conversation préchargée. Dans cet exemple, je demande qui est mon musicien préféré (Taylor Swift). Que se passe-t-il en arrière-plan ici ? L’objet mémoire utilise le modèle d’embedding fourni pour vectoriser le prompt et rechercher dans l’historique.
print(memory.load_memory_variables({"prompt": "who is my favorite musician?"})["history"])
Nous devrions obtenir une sortie comme dans l’exemple ci-dessous.
Maintenant, nous créons un modèle de prompt pour alimenter la chaîne de conversation. C’est la partie où nous avons besoin d’un LLM. Tout ce que nous faisons ici, c’est importer Nebula et lui transmettre la clé API. Nous pouvons traiter le prompt comme une chaîne multiligne et utiliser la notation avec accolades pour transmettre des variables comme nous le faisons avec les f-strings.
Nous transmettons ensuite cette chaîne et les noms de variables dans un objet de modèle de prompt LangChain. Avec le modèle de prompt, le LLM et la mémoire, nous pouvons créer notre « conversation » à l’aide d’un objet de chaîne de conversation.
from langchain_community.llms.symblai_nebula import Nebula
llm = Nebula(nebula_api_key=api_key)
_DEFAULT_TEMPLATE = """The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
Relevant pieces of previous conversation:
{history}
(You do not need to use these pieces of information if not relevant)
Current conversation:
Human: {input}
AI:"""
PROMPT = PromptTemplate(
input_variables=["history", "input"], template=_DEFAULT_TEMPLATE
)
conversation_with_summary = ConversationChain(
llm=llm,
prompt=PROMPT,
memory=memory,
verbose=True
)
Posons la première question. Nous demandons simplement au LLM ce qui se passe.
conversation_with_summary.predict(input="Hi Nebula, what's up?")
Vous devriez voir une réponse comme celle ci-dessous. Avec la combinaison des données d’entraînement de Nebula et des données d’exemple que nous avons fournies, nous pouvons voir que le LLM s’attend à ce que nous, « Human », disions ensuite quelque chose.
Demandons-lui s’il connaît mon musicien préféré pour nos questions suivantes. Rappelez-vous que plus tôt, nous avons dit au LLM que mon musicien préféré est Taylor Swift, et nous avons conservé cette information en mémoire.
conversation_with_summary.predict(input="Who did I say was my favorite musician?")
Vous pouvez vous attendre à voir une réponse comme celle ci-dessous. Nous venons de créer une application RAG conversationnelle sans GPT.
Résumé de la création d’une application RAG conversationnelle sans OpenAI
Cet article est le premier volet d’une série de tutoriels sur la création d’applications RAG sans OpenAI. Dans ce tutoriel, nous avons examiné Nebula, un LLM conversationnel créé par Symbl AI. Nous avons utilisé Milvus comme base de données vectorielle, MPNet V2 de Hugging Face comme modèle d’embedding, et LangChain pour orchestrer le tout.
Pour cet exemple, nous avons créé une application RAG conversationnelle. Nous avons configuré notre application en lançant Milvus comme base de données vectorielle et en obtenant notre modèle d’embedding auprès de Hugging Face. Ensuite, nous utilisons LangChain pour utiliser Milvus comme magasin de mémoire avec MPNet V2 comme modèle d’embedding pour notre mémoire.
Une fois les étapes précédentes prêtes, nous créons une conversation afin d’avoir des données avec lesquelles travailler. Nous chargeons la conversation en mémoire et vérifions rapidement que les données sont bien là. Ensuite, nous préparons notre prompt et notre LLM. Puis, nous chargeons toutes ces données dans un objet de chaîne de conversation afin de pouvoir poser des questions.
Nous posons deux questions à l’application RAG conversationnelle pour conclure cet exemple. « Quoi de neuf ? » et « Qui est mon musicien préféré ? » Restez à l’écoute alors que nous continuons à développer cette série !
Pour un résumé de cette implémentation, consultez le blog publié par Symbl.ai.
Continuer à lire
Introducing Zilliz CLI and Agent Skills for Zilliz Cloud
Manage your vector database from your terminal or AI coding agent. Zilliz CLI and Agent Skills work with Claude Code, Cursor, Codex, and Copilot.
AI Agents Are Quietly Transforming E-Commerce — Here’s How
Discover how AI agents transform e-commerce with autonomous decision-making, enhanced product discovery, and vector search capabilities for today's retailers.
Vector Databases vs. Key-Value Databases
Use a vector database for AI-powered similarity search; use a key-value database for high-throughput, low-latency simple data lookups.