Creare app RAG senza OpenAI - Parte uno
OpenAI è il large language model (LLM) più comunemente conosciuto. Ma non è l’unico LLM. Se sei un lettore abituale di questo blog, sai già che abbiamo creato molte applicazioni di tipo RAG usando LangChain, Milvus e OpenAI. In questo progetto, inseriamo Nebula (fai clic sul sito web di Nebula per richiedere una chiave API) come sostituto di OpenAI, e usiamo un modello di embedding di Hugging Face al posto degli embedding di OpenAI.
In questo post tratteremo:
Stack tecnologico RAG conversazionale
LangChain
Symbl AI
Milvus
Hugging Face
Come creare un’app RAG conversazionale di base
Configura il tuo stack RAG conversazionale
Crea la tua conversazione
Fai domande
Riepilogo della creazione di un RAG conversazionale senza OpenAI
Stack tecnologico RAG conversazionale
Il RAG conversazionale è la forma più comune di RAG. È ciò a cui pensiamo quando pensiamo ai chatbot RAG. L’anno scorso abbiamo discusso di come CVP (LLM simile a ChatGPT + database vettoriale + prompt come codice) sia lo stack canonico per RAG. In questo stack, aggiungiamo un modello in più: un modello di embedding separato da Hugging Face. Questo stack usa LangChain per l’orchestrazione dei prompt, Symbl AI per fornire l’LLM, Milvus come database vettoriale e Hugging Face come nostro modello di embedding.
LangChain
Se non ne hai sentito parlare, lo stai sentendo ora: LangChain è il framework di orchestrazione di app LLM più popolare. Questo tutorial è un adattamento di un progetto che abbiamo realizzato usando la memoria conversazionale con LangChain e OpenAI. Questa volta realizziamo lo stesso progetto senza embedding OpenAI né GPT.
Symbl AI
Symbl AI ha creato un LLM conversazionale addestrato su dati di conversazione. Il loro LLM si chiama Nebula e ha un’integrazione con LangChain. In questo tutorial, sostituiamo Nebula al GPT-3.5 di OpenAI, che avevamo usato in precedenza.
Milvus
La stella splendente del nostro articolo sulla memoria conversazionale è un database vettoriale. Come discusso, i database vettoriali sono progettati per lavorare con dati non strutturati una volta trasformati in vettori. Usiamo Milvus come archivio per la parte di memoria conversazionale di questo progetto.
Hugging Face
Hugging Face è il più grande hub di modelli al mondo. Si integra anche direttamente in LangChain. Usiamo un modello di embedding di Hugging Face invece degli embedding OpenAI che abbiamo usato nel nostro ultimo progetto.
Come creare un’app RAG conversazionale di base
Ora che conosciamo lo stack tecnologico:
C’è un po’ di configurazione da fare.
Definiamo una conversazione di esempio su cui l’app eseguirà RAG.
Concludiamo ponendo una domanda di esempio.
Configura il tuo stack RAG conversazionale
Configuriamo il nostro stack RAG conversazionale. Dobbiamo installare sei librerie: LangChain, Milvus (Lite), PyMilvus, python-dotenv e Sentence Transformers. Nella prima sezione, importiamo alcuni dei componenti essenziali da LangChain: gli oggetti Vector Store Retriever Memory, Conversation Chain e Prompt Template. Usiamo questi componenti per creare il nostro esempio di memoria conversazionale.
Due degli altri import sono `os` e `load_dotenv`. Li usiamo per caricare le nostre variabili d’ambiente. Se ricordi altri tutorial che abbiamo realizzato, di solito carichiamo la nostra chiave API di OpenAI; questa volta, stiamo caricando la chiave API di 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")
Successivamente, iniziamo con il nostro database vettoriale e il modello di embedding. Importiamo il `default_server` da Milvus Lite e lo avviamo per il nostro database vettoriale. Poi importiamo gli embedding di Hugging Face da LangChain e li usiamo come nostra funzione di embedding. Il modello predefinito è `all-mpnet-base-v2`, che ha una dimensionalità di 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 sezione seguente è più una sezione di “pulizia”. È irrilevante se non hai ancora usato LangChain con Milvus. Qui ci connettiamo a Milvus ed eliminiamo la collection LangChain esistente per evitare l’avvelenamento dei dati.
from pymilvus import utility, connections
connections.connect(host="127.0.0.1", port=default_server.listen_port)
utility.drop_collection('LangChainCollection')
Crea la tua conversazione
Ora è il momento di creare e archiviare la nostra conversazione.
Iniziamo importando un oggetto collection di vector store Milvus da LangChain e avviandolo con un insieme vuoto di documenti. Gli passiamo anche la funzione di embedding di Hugging Face che abbiamo creato in precedenza. Passiamo l’host e la porta della nostra istanza Milvus Lite per gli argomenti di connessione. L’ultimo parametro per questo oggetto che useremo questa volta è `consistency_level`, che imposta il livello di consistenza dei dati, in questo caso - “Strong”, il livello più alto di consistenza dei dati disponibile.
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")
Successivamente, configureremo un retriever di vector store usando LangChain, passando la collection Milvus e gli argomenti di ricerca. Per questa ricerca, vogliamo ottenere solo il primo risultato. Poi passeremo questo retriever a un oggetto memory che possiamo usare con gli LLM come parte dello stack RAG di LangChain.
Abbiamo anche bisogno di una conversazione iniziale. Nella vita reale, questa conversazione è come una chiamata al servizio clienti. In questo esempio, fornirò alcune informazioni su di me. Dovresti fornire alcune informazioni su di te. Una volta creata una conversazione di esempio, dobbiamo salvarla nella nostra memory come contesto.
Quando salviamo il contesto, passiamo due dizionari al nostro oggetto memory. Per questo esempio, passiamo l’input e l’output di esempio rispettivamente come “input” e “output”. Se vuoi sperimentare, puoi passare qualsiasi cosa desideri come chiavi e valori per la funzione `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"]})
Fai domande
Ora è tutto pronto per porre domande alla nostra app RAG conversazionale. In questo caso, ha un database vettoriale con la memoria della nostra conversazione finora, un modello di embedding di Hugging Face e un LLM non OpenAI, Nebula. Prima di fare qualsiasi domanda, controlliamo rapidamente che l’app ricordi la nostra conversazione.
Chiediamogli di mostrarci se ricorda qualcosa dalla conversazione precaricata. In questo esempio, sto chiedendo chi sia il mio musicista preferito (Taylor Swift). Cosa sta succedendo qui in background? L’oggetto memory usa il modello di embedding fornito per vettorizzare il prompt e cercare nella cronologia.
print(memory.load_memory_variables({"prompt": "who is my favorite musician?"})["history"])
Dovremmo ottenere un output come nell’esempio qui sotto.
Ora creiamo un template di prompt da fornire alla conversation chain. Questa è la parte in cui abbiamo bisogno di un LLM. Tutto ciò che facciamo qui è importare Nebula e passargli la chiave API. Possiamo trattare il prompt come una stringa multilinea e usare la notazione con parentesi graffe per passare le variabili, come facciamo con le f-string.
Poi passiamo questa stringa e i nomi delle variabili in un oggetto template di prompt di LangChain. Con il template di prompt, l’LLM e la memory, possiamo creare la nostra “conversazione” usando un oggetto conversation chain.
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
)
Facciamo la prima domanda. Chiediamo semplicemente all’LLM come va.
conversation_with_summary.predict(input="Hi Nebula, what's up?")
Dovresti vedere una risposta come quella qui sotto. Con la combinazione dei dati di addestramento di Nebula e dei dati di esempio che abbiamo fornito, possiamo vedere che l’LLM si aspetta che noi, “Human,” diciamo qualcosa dopo.
Chiediamogli se conosce il mio musicista preferito per le nostre domande successive. Ricorda che prima abbiamo detto all’LLM che il mio musicista preferito è Taylor Swift, e abbiamo conservato questa informazione nella memory.
conversation_with_summary.predict(input="Who did I say was my favorite musician?")
Puoi aspettarti di vedere una risposta come quella qui sotto. Abbiamo appena creato un’app RAG conversazionale senza GPT.
Riepilogo della creazione di un’app RAG conversazionale senza OpenAI
Questo post è il primo capitolo di una serie di tutorial sulla creazione di app RAG senza OpenAI. In questo tutorial, abbiamo esaminato Nebula, un LLM conversazionale creato da Symbl AI. Abbiamo usato Milvus come database vettoriale, MPNet V2 di Hugging Face come modello di embedding e LangChain per orchestrare tutto.
Per questo esempio, abbiamo creato un’app RAG conversazionale. Abbiamo configurato la nostra app avviando Milvus come database vettoriale e ottenendo il nostro modello di embedding da Hugging Face. Poi, usiamo LangChain per utilizzare Milvus come nostro archivio di memory con MPNet V2 come modello di embedding per la nostra memory.
Con i passaggi precedenti pronti, creiamo una conversazione per avere dati con cui lavorare. Carichiamo la conversazione nella memory e controlliamo rapidamente che i dati siano presenti. Successivamente, prepariamo il nostro prompt e l’LLM. Poi carichiamo tutti questi dati in un oggetto conversation chain in modo da poter fare domande.
Poniamo all’app RAG conversazionale due domande per concludere questo esempio. “Come va?” e “Chi è il mio musicista preferito?” Restate sintonizzati mentre continuiamo a sviluppare questa serie!
Per un riepilogo di questa implementazione, consulta il blog pubblicato da Symbl.ai.
Continua a leggere
Zilliz Cloud BYOC Now Available Across AWS, GCP, and Azure
Zilliz Cloud BYOC is now generally available on all three major clouds. Deploy fully managed vector search in your own AWS, GCP, or Azure account — your data never leaves your VPC.
Introducing Zilliz Cloud Global Cluster: Region-Level Resilience for Mission-Critical AI
Zilliz Cloud Global Cluster delivers multi-region resilience, automatic failover, and fast global AI search with built-in security and compliance.
Why and How to Migrate from Self-Hosted Milvus to Zilliz Cloud
A simple, step-by-step guide to migrating from Milvus to Zilliz Cloud. Learn both endpoint and backup methods for a smooth, scalable vector database migration.