Otimizando a relevância usando MongoDB Atlas e LlamaIndex
Avalie esse Tutorial
No último ano, houve um aumento nas experiências de linguagem natural em aplicativos voltados para o usuário, desde chatbots e agentes RAG (RAG (RAG) até pesquisa de linguagem natural. Com a linguagem natural se tornando a nova linguagem de query, a pesquisa de texto completo baseada em palavras-chave nem sempre recupera os melhores resultados devido ao tamanho, parafraseamento, ambiguidade e vaguidade das queries de linguagem natural.
A pesquisa semântica se tornou uma escolha popular para esses aplicativos, pois recupera informações com base na similaridade conceitual, em vez de nas correspondências de palavras-chave.
Mas e se pudermos otimizar tanto para similaridade conceitual quanto para palavras-chave importantes?
Neste tutorial, exploraremos diferentes estratégias para otimizar a relevância em aplicativos RAG e pesquisa de linguagem natural, com foco na pesquisa híbrida.
Especificamente, abordaremos o seguinte:
- O que é pesquisa híbrida?
- Casos de uso para pesquisa híbrida
- Ajustando a pesquisa híbrida para obter melhores resultados
- Combinando filtros de metadados com pesquisa
A pesquisa híbrida é uma técnica que combina os resultados de várias metodologias de pesquisa para melhorar a relevância e a precisão dos resultados da pesquisa. As metodologias de pesquisa a serem combinadas dependem do caso de uso – em aplicativos RAG e de pesquisa de linguagem natural, é comum combinar pesquisa semântica com pesquisa de texto completo para recuperar uma combinação de documentos contextualmente precisos e altamente relevantes.
Veja alguns exemplos de aplicativos em que a pesquisa híbrida é útil:
- Pesquisa de produto: uma pesquisa por "red running shoes, ", por exemplo, deve retornar resultados que correspondam às palavras-chave exatas na consulta, mas também pode conter produtos relacionados, como meias e coletes de treinamento que correspondam à intenção da consulta.
- chatbots de suporte aocliente : os clientes podem mencionar códigos de erro precisos ou nomes de função em suas queries, mas o chatbot precisará recuperar a documentação sobre o código de erro exato e também outras questões relacionadas para entender completamente o problema e fornecer uma solução.
- Pesquisa e recomendaçõesde conteúdo: nos sistemas de recomendações de conteúdo para notícias, filmes etc., a pesquisa híbrida pode ajudar a equilibrar precisão e variedade, ajudam os usuários não apenas a encontrar conteúdo relevante, mas também a descobrir conteúdo novo e diverso que talvez não tenham pesquisado explicitamente. Ele também pode ajudar em situações em que o usuário só tem determinadas palavras-chave ou temas em mente, mas não sabe exatamente o que está procurando.
Neste tutorial, vamos nos concentrar em um sistema de recomendações de filmes usando MongoDB e LlamaIndex. Veremos como realizar pesquisas de texto completo, vetoriais e híbridas usando a integração LlamaIndex do MongoDB e explorar maneiras de ajustá-las para otimizar a relevância.
Vamos precisar das seguintes bibliotecas para este tutorial:
- PyMongo: Pacote Python para interagir com bancos de dados e coleções MongoDB
- llama-index: pacote do Python para a estrutura LlamaIndex LLM
- llama-index-llms-openai: pacote Python para usar modelos OpenAI por meio de sua integração LlamaIndex
- llama-index-vector-stores-mongodb: pacote Python para integração LlamaIndex do MongoDB
1 !pip install -qU pymongo llama-index llama-index-llms-openai llama-index-vector-stores-mongodb
Neste tutorial, usaremos o modelo
text-embedding-3-small
do OpenAI para gerar incorporações para pesquisa vetorial. Para usar seus modelos, você precisa obter uma chave de API e defini-la como uma variável de ambiente:1 os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter your OpenAI API key: ")
Usaremos o MongoDB como um armazenamento de vetor e realizaremos pesquisas de texto completo, vetoriais e híbridas nele. Mas, primeiro, você precisará de uma conta do MongoDB Atlas com um cluster de banco de dados de dados. Depois de fazer isso, você precisará obter a string de conexão para se conectar ao cluster. Siga estas etapas para configurar:
- Obtenha a stringde conexão para seu cluster de banco de dados.
Após obter a string de conexão , defina - a em seu código e instancie o cliente MongoDB para se conectar ao seu banco de dados de dados .
1 MONGODB_URI = getpass.getpass("Enter your MongoDB URI: ") 2 mongodb_client = MongoClient( 3 MONGODB_URI, appname="devrel.content.retrieval_strategies_llamaindex" 4 )
Neste tutorial, usaremos o conjunto de dados
embedded_movies
do MongoDB, que está disponível no HuggingFace. O conjunto de dados contém uma lista de filmes, seus lotes e outros metadados úteis sobre os filmes, como gêneros, classificações, informações de elenco, etc. Vamos baixar o conjunto de dados e fazer um pré-processamento básico.1 # Load the dataset 2 data = load_dataset("MongoDB/embedded_movies", split="train") 3 data = pd.DataFrame(data) 4 5 # Fill Nones in the dataframe 6 data = data.fillna({"genres": "[]", "languages": "[]", "cast": "[]", "imdb": "{}"})
O código acima carrega o conjunto de dados do HuggingFace como um dataframe Pandas e preenche os valores
None
ou NaN
no dataframe resultante com os padrões apropriados.Em seguida, vamos converter o dataframe em uma lista de documentos LlamaIndex. Documentos são uma abstração central no LlamaIndex e são essencialmente uma classe para armazenar um pedaço de texto e metadados associados.
1 documents = [] 2 for _, row in data.iterrows(): 3 # Extract required fields 4 title = row["title"] 5 rating = row["imdb"].get("rating", 0) 6 languages = row["languages"] 7 cast = row["cast"] 8 genres = row["genres"] 9 # Create the metadata attribute 10 metadata = {"title": title, "rating": rating, "languages": languages} 11 # Create the text attribute 12 text = f"Title: {title}\nPlot: {row['fullplot']}\nCast: {', '.join(item for item in cast)}\nGenres: {', '.join(item for item in genres)}\nLanguages: {', '.join(item for item in languages)}\nRating: {rating}" 13 documents.append(Document(text=text, metadata=metadata))
O código acima itera pelas linhas do dataframe e:
- Extrai um subconjunto de colunas de metadados de cada linha. O conjunto de dados tem muitos metadados para cada filme, mas não precisamos de todos eles.
- Converte cada linha em um documento LlamaIndex . O atributo
text
do documento é uma string concatenada que consiste em informações adequadas tanto para pesquisa vetorial (por exemplo, título, plot do filme), quanto para pesquisa de texto completo (por exemplo, elenco, gênero).
Um exemplo de um documento LlamaIndex é o seguinte:
1 Document(id_='df580995-076f-444e-ae21-9ba596a6a224', embedding=None, metadata={'title': 'The Perils of Pauline', 'rating': 7.6, 'languages': ['English']}, excluded_embed_metadata_keys=[], excluded_llm_metadata_keys=[], relationships={}, text='Title: The Perils of Pauline\nPlot: Young Pauline is left a lot of money...\nCast: Pearl White, Crane Wilbur, Paul Panzer, Edward Josè\nGenres: Action\nLanguages: English\nRating: 7.6', mimetype='text/plain', start_char_idx=None, end_char_idx=None, text_template='{metadata_str}\n\n{content}', metadata_template='{key}: {value}', metadata_seperator='\n')
As tags são uma forma comum de caracterizar o conteúdo em sistemas de recomendações. Se você os tiver em seu conjunto de dados, inclua-os no atributo
text
para ajudar na pesquisa de texto completo, bem como no atributometadata
para filtrar potencialmente essas tags com base nas preferências do usuário.Para realizar pesquisa vetorial e híbrida em nossos dados, primeiro precisamos incorporá-los e ingeri-los em uma coleção do MongoDB para criar um armazenamento de vetores.
1 from llama_index.embeddings.openai import OpenAIEmbedding 2 from llama_index.vector_stores.mongodb import MongoDBAtlasVectorSearch 3 from llama_index.core.settings import Settings 4 from llama_index.core import VectorStoreIndex, StorageContext 5 6 Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") 7 8 VS_INDEX_NAME = "vector_index" 9 FTS_INDEX_NAME = "fts_index" 10 DB_NAME = "llamaindex" 11 COLLECTION_NAME = "hybrid_search" 12 collection = mongodb_client[DB_NAME][COLLECTION_NAME] 13 14 vector_store = MongoDBAtlasVectorSearch( 15 mongodb_client, 16 db_name=DB_NAME, 17 collection_name=COLLECTION_NAME, 18 vector_index_name=VS_INDEX_NAME, 19 fulltext_index_name=FTS_INDEX_NAME, 20 embedding_key="embedding", 21 text_key="text", 22 ) 23 # If the collection has documents with embeddings already, create the vector store index from the vector store 24 if collection.count_documents({}) > 0: 25 vector_store_index = VectorStoreIndex.from_vector_store(vector_store) 26 # If the collection does not have documents, embed and ingest them into the vector store 27 else: 28 vector_store_context = StorageContext.from_defaults(vector_store=vector_store) 29 vector_store_index = VectorStoreIndex.from_documents( 30 documents, storage_context=vector_store_context, show_progress=True 31 )
O código acima:
- Especifica o modelo de incorporação a ser usado definindo o atributo
embed_model
do {Settings
. Usaremos o modelotext-embedding-3-small
da OpenAI. Em LlamaIndex,Settings
é um objeto usado para especificar várias definições de configuração global, como LLM, modelo de incorporação, divisor de texto etc., para seu aplicação. - Especifica o nome do banco de banco de dados MongoDB (
DB_NAME
) e da collection (COLLECTION_NAME
) para fazer a ingestão de dados, e os nomes dos índices vetoriais (VS_INDEX_NAME
) e de texto completo (FTS_INDEX_NAME
) para usar. - Inicializa um armazenamento de vetores do MongoDB Atlas usando a classe
MongoDBAtlasVectorSearch
da integração LlamaIndex do MongoDB. O objeto de armazenamento de vetor especifica o banco de dados de dados (db_name
) e a coleção (collection_name
) a serem usados, os nomes dos índices de pesquisa vetorial (vector_index_name
) e de texto completo (fulltext_index_name
) e o caminho para o embeddings (embedding_key
) e texto (text_key
) para pesquisa vetorial e pesquisa de texto completo, respectivamente. - Cria um índice de armazenamento de vetor usando o método
from_vector_store
se o armazenamento de vetor do MongoDB Atlas já tiver documentos com incorporações. Caso contrário, criamos um contexto de armazenamento que gerencia onde os documentos e incorporações são armazenados — neste caso, o armazenamento de vetores do MongoDB Atlas . Em seguida, criamos o índice do armazenamento de vetor usando o métodofrom_documents
e o armazenamento de vetor do MongoDB Atlas como o contexto de armazenamento. Sob o capô, o índice chunks, incorpora e ingere os documentos que criamos no MongoDB Atlas.
Para executar pesquisas de texto completo e vetoriais em seus dados no MongoDB Atlas, primeiro você precisa criar índices de pesquisa de texto completo e vetorial, respectivamente.
NOTA: os índices do MongoDB não devem ser confundidos com os índices do LlamaIndex. Os índices no MongoDB são necessários para recuperar dados do MongoDB com eficiência. Os índices no LlamaIndex são necessários se você quiser consultar seus dados usando o LlamaIndex. Então, você precisa de ambos ao usar o MongoDB como um armazenamento de vetor com o LlamaIndex.
1 vs_model = SearchIndexModel( 2 definition={ 3 "fields": [ 4 { 5 "type": "vector", 6 "path": "embedding", 7 "numDimensions": 1536, 8 "similarity": "cosine", 9 }, 10 {"type": "filter", "path": "metadata.rating"}, 11 {"type": "filter", "path": "metadata.language"}, 12 ] 13 }, 14 name=VS_INDEX_NAME, 15 type="vectorSearch", 16 )
O código acima cria um modelo para o índice de pesquisa vetorial . O modelo especifica:
- A definição do índice, que, por sua vez, especifica o caminho para o campo de incorporação (
embedding
), o número de dimensões de incorporação (numDimensions
) e a métrica de similaridade (similarity
) a ser usado para medir a distância de incorporação. Também podemos especificar campos a serem usados como pré-filtros durante a pesquisa vetorial, neste caso, classificação de filmes e idiomas. A pré-filtragem é uma forma de restringir o escopo da pesquisa vetorial com base em determinados critérios e pode ajudar a melhorar a velocidade e a qualidade da pesquisa. - O nome do índice (
name
). - O tipo de índice, neste caso
vectorSearch
.
Em seguida, criaremos um modelo para o índice de pesquisa de texto completo :
1 fts_model = SearchIndexModel( 2 definition={"mappings": {"dynamic": False, "fields": {"text": {"type": "string"}}}}, 3 name=FTS_INDEX_NAME, 4 type="search", 5 )
A definição do índice para o índice de pesquisa de texto completo parece um pouco diferente do índice de pesquisa vetorial. Para a pesquisa de texto completo, especificamos
mappings
que define como os campos do documento são processados, analisados e armazenados para uma funcionalidade de pesquisa de texto completo eficiente e precisa. Nesse caso, definimos dynamic
como False
para indicar que não queremos que o índice de índice de pesquisa os campos automaticamente. Em vez disso, especificaremos os campos que queremos indexar e seus tipos em mappings.fields
. Além disso, observe que o índice type
para pesquisa de texto completo é search
.Use mapeamentos dinâmicos se seu esquema mudar regularmente ou for desconhecido.
Finalmente, vamos criar os índices de pesquisa para a collection que contém nossos dados. Se um índice já existir, exibiremos uma mensagem de erro apropriada e pularemos a criação do índice:
1 for model in [vs_model, fts_model]: 2 try: 3 collection.create_search_index(model=model) 4 except OperationFailure: 5 print(f"Duplicate index found for model {model}. Skipping index creation.")
Agora que geramos incorporações e ingerimos e indexamos nosso conjunto de dados de filmes no MongoDB Atlas, estamos prontos para usá-lo para fazer recomendações de filmes.
Vamos definir uma função para fazer isso:
1 def get_recommendations(query: str, mode: str, **kwargs) -> None: 2 """ 3 Get movie recommendations 4 5 Args: 6 query (str): User query 7 mode (str): Retrieval mode. One of (default, text_search, hybrid) 8 """ 9 query_engine = vector_store_index.as_query_engine( 10 similarity_top_k=5, vector_store_query_mode=mode, **kwargs 11 ) 12 response = query_engine.query(query) 13 nodes = response.source_nodes 14 for node in nodes: 15 title = node.metadata["title"] 16 rating = node.metadata["rating"] 17 score = node.score 18 print(f"Title: {title} | Rating: {rating} | Relevance Score: {score}")
A função
get_recommendations
no código acima:- Aceita uma consulta de usuário de linguagem natural (
query
), um modo de pesquisa (mode
) e quaisquer argumentos adicionais como entrada. O modo de pesquisa pode sertext_search
para pesquisa de texto completo,default
para pesquisa vetorial ehybrid
para pesquisa híbrida. - Converte o índice do armazenamento de vetor criado na etapa 4 em um mecanismo de query. O mecanismo de query no LlamaIndex é uma interface para fazer perguntas sobre seus dados e definir as configurações de query. Converter um índice existente em um mecanismo de query é tão simples quanto fazer
<index_name>.as_query_engine()
. Você também pode especificar parâmetros para sua pesquisa na chamadaas_query_engine
— em nosso caso, definiremossimilarity_top_k
como 5 para obter os cinco resultados mais relevantes de nossas pesquisas evector_store_query_mode
para indicar o modo de pesquisa. - Executa a query no mecanismo de query, recupera os nós retornados, itera por eles e imprime o título do filme, a classificação e a pontuação de relevância para cada nó.
Um nó no LlamaIndex representa um bloco de um documento de origem. Nos seus fundamentos, os índices do LlamaIndex armazenam dados como objetos de nó; portanto, quando consultado, você recupera nós do índice.'
Agora, vamos consultar nossos dados com diferentes modos de pesquisa e observar as diferenças. Vamos começar com a pesquisa de texto completo.
1 get_recommendations( 2 query="Action movies about humans fighting machines", 3 mode="text_search", 4 ) 5 6 Title: Hellboy II: The Golden Army | Rating: 7.0 | Relevance Score: 5.93734884262085 7 Title: The Matrix Revolutions | Rating: 6.7 | Relevance Score: 4.574477195739746 8 Title: The Matrix | Rating: 8.7 | Relevance Score: 4.387373924255371 9 Title: Go with Peace Jamil | Rating: 6.9 | Relevance Score: 3.5394840240478516 10 Title: Terminator Salvation | Rating: 6.7 | Relevance Score: 3.3378987312316895
Se você observar os gráficos desses filmes em nosso conjunto de dados, verá que todos eles contêm as palavras-chave "humans " e "machines ", que correspondem bem à query do usuário.
Em seguida, vamos tentar a mesma query, mas com o modo de pesquisa como pesquisa vetorial. Para fazer isso, defina o parâmetro
mode
paradefault
na chamada para a funçãoget_recommendations()
:1 get_recommendations( 2 query="Action movies about humans fighting machines", mode="default" 3 ) 4 5 Title: Death Machine | Rating: 5.7 | Relevance Score: 0.7407287359237671 6 Title: Real Steel | Rating: 7.1 | Relevance Score: 0.7364246845245361 7 Title: Soldier | Rating: 5.9 | Relevance Score: 0.7282171249389648 8 Title: Terminator 3: Rise of the Machines | Rating: 6.4 | Relevance Score: 0.7266112565994263 9 Title: Last Action Hero | Rating: 6.2 | Relevance Score: 0.7250100374221802
Observe a diferença nas recomendações. Os lotes dos filmes recomendados acima fala sobre socie dades futurísticas, Soldados humanos enfrentando humanos “another breed of soldiers,” ensinando bots a boxear, etc., que são tematicamente relacionados à query do usuário sem conter as palavras-chave exatas.
Observe a diferença nas escalas entre a pesquisa de texto completo e vetorial. Consulte nossa documentação para saber mais sobre as metodologias de pontuação do Atlas Search e do Atlas Vector Search.
Agora, vamos tentar a query com o modo de pesquisa como pesquisa híbrida. Para fazer isso, defina o parâmetro
mode
parahybrid
na chamada de funçãoget_recommendations()
:1 get_recommendations(query="Action movies about humans fighting machines", mode="hybrid") 2 3 Title: Hellboy II: The Golden Army | Rating: 7.0 | Relevance Score: 0.5 4 Title: Death Machine | Rating: 5.7 | Relevance Score: 0.5 5 Title: The Matrix Revolutions | Rating: 6.7 | Relevance Score: 0.25 6 Title: Real Steel | Rating: 7.1 | Relevance Score: 0.25 7 Title: Soldier | Rating: 5.9 | Relevance Score: 0.16666666666666666
Nesse caso, a lista de recomendações é uma combinação de recomendações obtidas a partir de pesquisas vetoriais e de texto completo. Observe que as pontuações de relevância para os mesmos filmes agora são diferentes. Isso ocorre porque as pontuações da pesquisa vetorial e da pesquisa de texto completo são combinadas usando a fusão recíproca de classificações (RRF). Essa técnica combina classificações de várias pesquisas atribuindo uma pontuação a cada documento com base no reverso de sua classificação em cada lista e, opcionalmente, um peso atribuído a cada metodologia de pesquisa.
Por padrão, o RRF atribui um peso igual a cada técnica de pesquisa. No entanto, você pode alterar isso passando um argumento adicional,
alpha
, para o mecanismo de query. Pode ser um valor entre 0 e 1, em que um valor mais próximo de 1 aumentará o peso da pesquisa vetorial ao combinar as pontuações, e um valor mais próximo de 0 significa que a pesquisa de texto completo assumirá o domínio. O valor de alpha
é 0.5 por padrão para indicar ponderação igual.1 # Higher alpha, vector search dominates 2 get_recommendations( 3 query="Action movies about humans fighting machines", 4 mode="hybrid", 5 alpha=0.7, 6 ) 7 8 Title: Death Machine | Rating: 5.7 | Relevance Score: 0.7 9 Title: Real Steel | Rating: 7.1 | Relevance Score: 0.35 10 Title: Hellboy II: The Golden Army | Rating: 7.0 | Relevance Score: 0.30000000000000004 11 Title: Soldier | Rating: 5.9 | Relevance Score: 0.2333333333333333 12 Title: Terminator 3: Rise of the Machines | Rating: 6.4 | Relevance Score: 0.175
No código acima, passamos
alpha
como um argumento para a funçãoget_recommendations()
e ele é encaminhado para o mecanismo de query. Com alpha
definido como 0.7, observe que os resultados da pesquisa vetorial são pontuados e, portanto, classificados como superiores aos resultados da pesquisa de texto completo na lista final de recomendações.Agora, vamos definir
alpha
para um valor menor que 0.5 e ver o que muda:1 # Lower alpha, full-text search dominates 2 get_recommendations( 3 query="Action movies about humans fighting machines", 4 mode="hybrid", 5 alpha=0.3, 6 ) 7 8 Title: Hellboy II: The Golden Army | Rating: 7.0 | Relevance Score: 0.7 9 Title: The Matrix Revolutions | Rating: 6.7 | Relevance Score: 0.35 10 Title: Death Machine | Rating: 5.7 | Relevance Score: 0.3 11 Title: The Matrix | Rating: 8.7 | Relevance Score: 0.2333333333333333 12 Title: Go with Peace Jamil | Rating: 6.9 | Relevance Score: 0.175
No código acima, definimos
alpha
como 0.3 e notamos que os resultados de texto completo são pontuados e classificados acima dos resultados da pesquisa vetorial na lista final de recomendações.Muitas vezes, em sistemas de recomendações, além da recuperação, há uma etapa para filtrar os candidatos recuperados com base em determinados critérios, como preferências conhecidas do usuário ou lógica de negócios personalizada. Se você tiver esses critérios capturados como metadados em seus documentos no MongoDB Atlas, poderá até mesmo pré-filtrar documentos para obter um aumento de eficiência, em vez de aplicar filtros após a recuperação.
Como etapa final deste tutorial, vejamos como combinar a pré-filtragem com a pesquisa híbrida. Vamos presumir que só queremos escolher filmes em inglês com uma classificação maior que 7/10.
1 from llama_index.core.vector_stores import ( 2 MetadataFilter, 3 MetadataFilters, 4 FilterOperator, 5 FilterCondition, 6 ) 7 8 filters = MetadataFilters( 9 filters=[ 10 MetadataFilter(key="metadata.rating", value=7, operator=FilterOperator.GT), 11 MetadataFilter( 12 key="metadata.languages", value="English", operator=FilterOperator.EQ 13 ), 14 ], 15 condition=FilterCondition.AND, 16 )
Em LlamaIndex, você pode especificar filtros de metadados como modelos Pydentic (
MetadataFilter
) contendo o campo de metadados para filtrar (key
), o valor de campo (value
) e um operador de filtro (operator
). Se você tiver várias condições de filtro, poderá combiná-las usando o modelo Pydantial MetadataFilters
, com um atributofilters
que consiste nas condições de filtro expressas como modelosMetadataFilter
e um atributocondition
especificando como combinar as condições de filtro — por exemplo, e, ou.No código acima, criamos dois filtros de metadados — um com
key
definido como metadata.rating, value
a 7, e operator
para FilterOperator.GT indicando "greater than " para filtrar filmes com uma classificação superior a 7, e outro com key
definido como metadata.languages, value
para inglêse operator
para FilterOperator.EQ, indicando "equal to " para filtrar filmes em inglês. Finalmente, combinamos esses filtros em um modeloMetadataFilters
com o condition
FilterCondition.AND para filtrar documentos em que ambas as condições de filtro sejam satisfeitas.1 get_recommendations( 2 query="Action movies about humans fighting machines", 3 mode="hybrid", 4 alpha=0.7, 5 filters=filters, 6 ) 7 8 Title: Real Steel | Rating: 7.1 | Relevance Score: 0.7 9 Title: T2 3-D: Battle Across Time | Rating: 7.8 | Relevance Score: 0.35 10 Title: The Matrix | Rating: 8.7 | Relevance Score: 0.30000000000000004 11 Title: Predator | Rating: 7.8 | Relevance Score: 0.2333333333333333 12 Title: Transformers | Rating: 7.1 | Relevance Score: 0.175
No código acima, passamos a mesma query de antes com o
mode
definido como híbrido, alpha
para 0.7, e um argumento filters
adicional definido para o modeloMetadataFilters
que definimos anteriormente. Nos comandos do MongoDB , o modelo de filtro é traduzido para os filtros de query e adicionado aos pipelines de pesquisa vetorial e de texto completo para filtrar os resultados da pesquisa.Neste tutorial, construímos um sistema de recomendações de conteúdo usando MongoDB e LlamaIndex. Exploramos diferentes modos de pesquisa, com foco na pesquisa híbrida, e também maneiras de ajustá-la para melhorar a relevância dos resultados da pesquisa. Em sistemas de recomendações de conteúdo, em particular, a pesquisa híbrida pode ajudar a equilibrar precisão e variedade, otimizando para palavras-chave e similaridade contextual.
Para explorar mais maneiras de melhorar a qualidade de recuperação de suas pesquisas, confira estes tutoriais no Centro do Desenvolvedor:
Principais comentários nos fóruns
Ainda não há comentários sobre este artigo.