Criando aplicativos RAG sem OpenAI - Parte Um
OpenAI é o modelo de linguagem de grande escala (LLM) mais comumente conhecido. Mas não é o único LLM. Se você é um leitor regular deste blog, já sabe que temos criado muitas aplicações do tipo RAG usando LangChain, Milvus e OpenAI. Neste projeto, inserimos o Nebula (clique no site da Nebula para solicitar uma chave de API) como substituto do OpenAI, e usamos um modelo de embeddings da Hugging Face no lugar dos embeddings da OpenAI.
Neste post, abordaremos:
Stack de tecnologia de RAG conversacional
LangChain
Symbl AI
Milvus
Hugging Face
Como criar uma aplicação básica de RAG conversacional
Configure sua stack de RAG conversacional
Crie sua conversa
Faça perguntas
Resumo da criação de um RAG conversacional sem OpenAI
Stack de tecnologia de RAG conversacional
RAG conversacional é a forma mais comum de RAG. É no que pensamos quando pensamos em chatbots RAG. No ano passado, discutimos como CVP (LLM como o ChatGPT + Banco de Dados Vetorial + Prompt como código) é a stack canônica para RAG. Nesta stack, adicionamos mais um modelo — um modelo de embeddings separado da Hugging Face. Esta stack usa LangChain para orquestração de prompts, Symbl AI para fornecer o LLM, Milvus como banco de dados vetorial e Hugging Face como nosso modelo de embeddings.
LangChain
Se você ainda não ouviu falar, está ouvindo agora: LangChain é o framework de orquestração de aplicações LLM mais popular. Este tutorial é uma adaptação de um projeto que fizemos usando memória conversacional com LangChain e OpenAI. Estamos fazendo o mesmo projeto desta vez sem embeddings da OpenAI ou GPT.
Symbl AI
A Symbl AI criou um LLM conversacional treinado em dados de conversas. O LLM deles se chama Nebula, e ele tem uma integração com LangChain. Neste tutorial, substituímos o GPT-3.5 da OpenAI pelo Nebula, que usamos anteriormente.
Milvus
A grande estrela da nossa peça de memória conversacional é um banco de dados vetorial. Como discutido, bancos de dados vetoriais são projetados para trabalhar com dados não estruturados depois de transformados em vetores. Usamos Milvus como nosso armazenamento para a parte de memória conversacional deste projeto.
Hugging Face
Hugging Face é o maior hub de modelos do mundo. Eles também se integram diretamente ao LangChain. Usamos um modelo de embeddings da Hugging Face em vez dos embeddings da OpenAI que usamos em nosso último projeto.
Como criar uma aplicação básica de RAG conversacional
Agora que conhecemos a stack de tecnologia:
Há um pouco de configuração a fazer.
Definimos uma conversa de exemplo para a aplicação executar RAG.
Finalizamos fazendo uma pergunta de exemplo.
Configure sua stack de RAG conversacional
Vamos configurar nossa stack de RAG conversacional. Precisamos instalar seis bibliotecas: LangChain, Milvus (Lite), PyMilvus, python-dotenv e Sentence Transformers. Na primeira seção, importamos algumas das peças essenciais do LangChain — os objetos Vector Store Retriever Memory, Conversation Chain e Prompt Template. Usamos essas peças para criar nosso exemplo de memória conversacional.
Duas das outras importações são `os` e `load_dotenv`. Usamos isso para carregar nossas variáveis de ambiente. Se você se lembra de outros tutoriais que fizemos, geralmente carregamos nossa chave de API da OpenAI; desta vez, estamos carregando a chave de API do 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")
A seguir, vamos começar com nosso banco de dados vetorial e modelo de embeddings. Importamos o `default_server` do Milvus Lite e o iniciamos para nosso banco de dados vetorial. Em seguida, importamos os embeddings da Hugging Face a partir do LangChain e os usamos como nossa função de embeddings. O modelo padrão é `all-mpnet-base-v2`, que tem uma dimensionalidade 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()
A seção a seguir é mais uma seção de “limpeza”. Ela é irrelevante se você ainda não usou LangChain com Milvus. Aqui, conectamos ao Milvus e removemos a coleção LangChain existente para evitar envenenamento de dados.
from pymilvus import utility, connections
connections.connect(host="127.0.0.1", port=default_server.listen_port)
utility.drop_collection('LangChainCollection')
Crie sua conversa
Agora, é hora de criar e armazenar nossa conversa.
Começamos importando um objeto de coleção de armazenamento vetorial Milvus do LangChain e iniciando-o com um conjunto vazio de documentos. Também passamos a ele a função de embeddings da Hugging Face que criamos anteriormente. Passamos o host e a porta da nossa instância do Milvus Lite para os argumentos de conexão. O último parâmetro para este objeto que usaremos desta vez é `consistency_level`, que define o nível de consistência dos dados, neste caso - “Strong”, o nível mais alto de consistência de dados disponível.
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")
Em seguida, configuraremos um recuperador de armazenamento vetorial usando LangChain, passando a coleção Milvus e os argumentos de busca. Para esta busca, queremos apenas o principal resultado de volta. Então, passaremos este recuperador para um objeto de memória que podemos usar com LLMs como parte da pilha RAG do LangChain.
Também precisamos de uma conversa inicial. Na vida real, essa conversa é como uma chamada de atendimento ao cliente. Neste exemplo, darei algumas informações sobre mim. Você deve dar a ele algumas informações sobre você. Com uma conversa de exemplo criada, precisamos salvá-la em nossa memória como contexto.
Ao salvar contexto, passamos dois dicionários para nosso objeto de memória. Para este exemplo, passamos a entrada e a saída de exemplo como “input” e “output”, respectivamente. Se quiser experimentar, você pode passar o que desejar para as chaves e valores da função `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"]})
Faça perguntas
Tudo está pronto para fazermos perguntas ao nosso aplicativo RAG conversacional agora. Neste caso, ele tem um banco de dados vetorial com a memória da nossa conversa até agora, um modelo de embeddings da Hugging Face e um LLM que não é da OpenAI, o Nebula. Antes de fazer qualquer pergunta, vamos verificar rapidamente para garantir que o aplicativo se lembra da nossa conversa.
Vamos pedir a ele que nos mostre se lembra de algo da conversa pré-carregada. Neste exemplo, estou perguntando quem é meu músico favorito (Taylor Swift). O que está acontecendo em segundo plano aqui? O objeto de memória usa o modelo de embedding fornecido para vetorizar o prompt e pesquisar o histórico.
print(memory.load_memory_variables({"prompt": "who is my favorite musician?"})["history"])
Devemos obter uma saída como a do exemplo abaixo.
Agora, criamos um template de prompt para alimentar a cadeia de conversação. Esta é a parte em que precisamos de um LLM. Tudo o que fazemos para isso aqui é importar Nebula e passar a ele a chave de API. Podemos tratar o prompt como uma string multilinha e usar a notação de chaves para passar variáveis, como fazemos com f-strings.
Em seguida, passamos essa string e os nomes das variáveis para um objeto de template de prompt do LangChain. Com o template de prompt, o LLM e a memória, podemos criar nossa “conversa” usando um objeto de cadeia de conversação.
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
)
Vamos fazer a primeira pergunta. Simplesmente perguntamos ao LLM como vai.
conversation_with_summary.predict(input="Hi Nebula, what's up?")
Você deve ver uma resposta como a abaixo. Com a combinação dos dados de treinamento do Nebula e os dados de exemplo que fornecemos, podemos ver que o LLM espera que nós, “Human,” digamos algo em seguida.
Vamos perguntar se ele sabe meu músico favorito para nossas próximas perguntas. Lembre-se de que, anteriormente, dissemos ao LLM que meu músico favorito é Taylor Swift, e mantivemos essa informação na memória.
conversation_with_summary.predict(input="Who did I say was my favorite musician?")
Você pode esperar ver uma resposta como a abaixo. Acabamos de criar um aplicativo RAG conversacional sem GPT.
Resumo da criação de um aplicativo RAG conversacional sem OpenAI
Este post é a primeira parte de uma série de tutoriais sobre a criação de aplicativos RAG sem OpenAI. Neste tutorial, analisamos o Nebula, um LLM conversacional criado pela Symbl AI. Usamos Milvus como nosso banco de dados vetorial, MPNet V2 da Hugging Face como nosso modelo de embedding e LangChain para orquestrar tudo.
Para este exemplo, criamos um aplicativo RAG conversacional. Configuramos nosso aplicativo inicializando o Milvus como nosso banco de dados vetorial e obtendo nosso modelo de embedding da Hugging Face. Em seguida, usamos LangChain para usar o Milvus como nosso armazenamento de memória, com MPNet V2 como nosso modelo de embedding para nossa memória.
Com as etapas anteriores prontas, criamos uma conversa para ter dados com os quais trabalhar. Carregamos a conversa na memória e verificamos rapidamente se os dados estão lá. Em seguida, preparamos nosso prompt e LLM. Depois, carregamos todos esses dados em um objeto de cadeia de conversação para que possamos fazer perguntas.
Fazemos duas perguntas ao aplicativo RAG conversacional para encerrar este exemplo. “Como vai?” e “Quem é meu músico favorito?” Fique ligado enquanto continuamos a desenvolver esta série!
Para um resumo desta implementação, consulte o blog publicado pela Symbl.ai.
Continue lendo
Stop Building AI Data Infra for the Wrong Stage
Learn how AI data infrastructure should evolve from prototype to enterprise scale, and when Vector Lakebase becomes the right architecture for AI apps.
VidTok: Rethinking Video Processing with Compact Tokenization
VidTok tokenizes videos to reduce redundancy while preserving spatial and temporal details for efficient processing.
Similarity Metrics for Vector Search
Exploring five similarity metrics for vector search: L2 or Euclidean distance, cosine distance, inner product, and hamming distance.