Explore o novo chatbot do Developer Center! O MongoDB AI chatbot pode ser acessado na parte superior da sua navegação para responder a todas as suas perguntas sobre o MongoDB .

Desenvolvedor do MongoDB
Central de desenvolvedor do MongoDBchevron-right
Produtoschevron-right
Atlaschevron-right

Otimizando a relevância usando MongoDB Atlas e LlamaIndex

Apoorva Joshi13 min read • Published Oct 02, 2024 • Updated Oct 02, 2024
IAPythonAtlas
Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
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

O que é pesquisa híbrida? Quando você deve usá-lo?

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.
O Notebook Jupyter para este tutorial pode ser encontrado no Github.

Etapa 1: instalar as bibliotecas necessárias

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

Etapa 2: configurar pré-requisitos

Neste tutorial, usaremos o modelo text-embedding-3-smalldo 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:
1os.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:
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 .
1MONGODB_URI = getpass.getpass("Enter your MongoDB URI: ")
2mongodb_client = MongoClient(
3 MONGODB_URI, appname="devrel.content.retrieval_strategies_llamaindex"
4)
Não se lembre de adicionar o IP da sua máquina host à lista de acesso IP do seu cluster.

Etapa 3: Carregue e processe o conjunto de dados

Neste tutorial, usaremos o conjunto de dadosembedded_moviesdo 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
2data = load_dataset("MongoDB/embedded_movies", split="train")
3data = pd.DataFrame(data)
4
5# Fill Nones in the dataframe
6data = data.fillna({"genres": "[]", "languages": "[]", "cast": "[]", "imdb": "{}"})
O código acima carrega o conjunto de dados do HuggingFace como um dataframe Pandas e preenche os valoresNone 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.
1documents = []
2for _, 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 atributotext 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:
1Document(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 atributotext para ajudar na pesquisa de texto completo, bem como no atributometadata para filtrar potencialmente essas tags com base nas preferências do usuário.

Etapa 4: Criar um repositório de vetores do MongoDB Atlas

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.
1from llama_index.embeddings.openai import OpenAIEmbedding
2from llama_index.vector_stores.mongodb import MongoDBAtlasVectorSearch
3from llama_index.core.settings import Settings
4from llama_index.core import VectorStoreIndex, StorageContext
5
6Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")
7
8VS_INDEX_NAME = "vector_index"
9FTS_INDEX_NAME = "fts_index"
10DB_NAME = "llamaindex"
11COLLECTION_NAME = "hybrid_search"
12collection = mongodb_client[DB_NAME][COLLECTION_NAME]
13
14vector_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
24if 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
27else:
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 atributoembed_modeldo {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 classeMongoDBAtlasVectorSearch 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étodofrom_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.

Etapa 5: Criar índices MongoDB Atlas Search

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.
1vs_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 :
1fts_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:
1for 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.")

Etapa 6: obtenha recomendações de filmes

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:
1def 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çãoget_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 ser text_search para pesquisa de texto completo, default para pesquisa vetorial e hybrid 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, definiremos similarity_top_k como 5 para obter os cinco resultados mais relevantes de nossas pesquisas e vector_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.
1get_recommendations(
2 query="Action movies about humans fighting machines",
3 mode="text_search",
4)
5
6Title: Hellboy II: The Golden Army | Rating: 7.0 | Relevance Score: 5.93734884262085
7Title: The Matrix Revolutions | Rating: 6.7 | Relevance Score: 4.574477195739746
8Title: The Matrix | Rating: 8.7 | Relevance Score: 4.387373924255371
9Title: Go with Peace Jamil | Rating: 6.9 | Relevance Score: 3.5394840240478516
10Title: 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 modeparadefault na chamada para a funçãoget_recommendations():
1get_recommendations(
2 query="Action movies about humans fighting machines", mode="default"
3)
4
5Title: Death Machine | Rating: 5.7 | Relevance Score: 0.7407287359237671
6Title: Real Steel | Rating: 7.1 | Relevance Score: 0.7364246845245361
7Title: Soldier | Rating: 5.9 | Relevance Score: 0.7282171249389648
8Title: Terminator 3: Rise of the Machines | Rating: 6.4 | Relevance Score: 0.7266112565994263
9Title: 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 modeparahybrid na chamada de funçãoget_recommendations():
1get_recommendations(query="Action movies about humans fighting machines", mode="hybrid")
2
3Title: Hellboy II: The Golden Army | Rating: 7.0 | Relevance Score: 0.5
4Title: Death Machine | Rating: 5.7 | Relevance Score: 0.5
5Title: The Matrix Revolutions | Rating: 6.7 | Relevance Score: 0.25
6Title: Real Steel | Rating: 7.1 | Relevance Score: 0.25
7Title: 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
2get_recommendations(
3 query="Action movies about humans fighting machines",
4 mode="hybrid",
5 alpha=0.7,
6)
7
8Title: Death Machine | Rating: 5.7 | Relevance Score: 0.7
9Title: Real Steel | Rating: 7.1 | Relevance Score: 0.35
10Title: Hellboy II: The Golden Army | Rating: 7.0 | Relevance Score: 0.30000000000000004
11Title: Soldier | Rating: 5.9 | Relevance Score: 0.2333333333333333
12Title: 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
2get_recommendations(
3 query="Action movies about humans fighting machines",
4 mode="hybrid",
5 alpha=0.3,
6)
7
8Title: Hellboy II: The Golden Army | Rating: 7.0 | Relevance Score: 0.7
9Title: The Matrix Revolutions | Rating: 6.7 | Relevance Score: 0.35
10Title: Death Machine | Rating: 5.7 | Relevance Score: 0.3
11Title: The Matrix | Rating: 8.7 | Relevance Score: 0.2333333333333333
12Title: 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.
1from llama_index.core.vector_stores import (
2 MetadataFilter,
3 MetadataFilters,
4 FilterOperator,
5 FilterCondition,
6)
7
8filters = 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.
1get_recommendations(
2 query="Action movies about humans fighting machines",
3 mode="hybrid",
4 alpha=0.7,
5 filters=filters,
6)
7
8Title: Real Steel | Rating: 7.1 | Relevance Score: 0.7
9Title: T2 3-D: Battle Across Time | Rating: 7.8 | Relevance Score: 0.35
10Title: The Matrix | Rating: 8.7 | Relevance Score: 0.30000000000000004
11Title: Predator | Rating: 7.8 | Relevance Score: 0.2333333333333333
12Title: 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 filtersadicional 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.

Conclusão

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.
Iniciar a conversa

Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Relacionado
Tutorial

Modelagem de dados em várias linguagens do Atlas Search


Sep 09, 2022 | 2 min read
Artigo

Comparação de técnicas de NLP para Atlas Search de produtos escaláveis


Sep 23, 2024 | 8 min read
Tutorial

Além do básico: aprimorando a API Kotlin Ktor com pesquisa vetorial


Sep 18, 2024 | 9 min read
Início rápido

Criando AI multiagentes de IA com BuildSship e MongoDB


Nov 18, 2024 | 3 min read
Sumário