Prakul Agarwal

Learn how to build generative AI (GenAI) applications by harnessing the power of MongoDB Atlas and Vector Search.

Building Generative AI Applications Using MongoDB: Harnessing the Power of Atlas Vector Search and Open Source Models

MongoDB

Han Heloir

Solutions Architect

Detect hallucinations with Patronus AI's Lynx model and MongoDB Atlas. Use HaluBench for RAG system evaluation and implement generative AI apps. 

RAG Evaluation: Detecting Hallucinations With Patronus AI and MongoDB

Anaiya Raisinghani

Associate Developer Advocate

In this tutorial, we will leverage the power of LangChain, MongoDB, and OpenAI to ingest and process data created after ChatGPT-3.5. Follow along to create your own chatbot that can read lengthy documents and provide insightful answers to complex queries!

### What is LangChain?
LangChain is a versatile Python library that enables developers to build applications that are powered by large language models (LLMs). LangChain actually helps facilitate the integration of various LLMs (ChatGPT-3, Hugging Face, etc.) in other applications and  understand and utilize recent information. As mentioned in the name, LangChain chains together different components, which are called links, to create a workflow. Each individual link performs a different task in the process, such as accessing a data source, calling a language model, processing output, etc. Since the order of these links can be moved around to create different workflows, LangChain is super flexible and can be used to build a large variety of applications. 

### LangChain and MongoDB
MongoDB integrates nicely with LangChain because of the semantic search capabilities provided by MongoDB Atlas’s vector search engine. This allows for the perfect combination where users can query based on meaning rather than by specific words! Apart from [MongoDB LangChain Python integration](https://python.langchain.com/docs/integrations/vectorstores/mongodb_atlas) and [MongoDB LangChain Javascript integration](https://js.langchain.com/docs/modules/data_connection/vectorstores/integrations/mongodb_atlas), MongoDB recently partnered with LangChain on the [LangChain templates ](https://www.mongodb.com/blog/post/announcing-langchain-templates-mongodb-atlas) release to make it easier for developers to build AI-powered apps.

## Prerequisites for success

 - MongoDB Atlas [account](https://www.mongodb.com/cloud/atlas/register)
 - OpenAI API [account](https://openai.com/blog/openai-api) and your API key
 - IDE of your choice (this tutorial uses [Google Colab](https://colab.research.google.com/drive/1k6gEGy--MmCWxoY-gfHZGGJx3k1B0mEr#scrollTo=BZLYniCQmYhi))

## Diving into the tutorial
Our first step is to ensure we’re downloading all the crucial packages we need to be successful in this tutorial. In Google Colab, please run the following command:

```
!pip install langchain pypdf pymongo openai python-dotenv tiktoken
```
Here, we’re installing six different packages in one. The first package is `langchain` (the package for the framework we are using to integrate language model capabilities), `pypdf` (a library for working with PDF documents in Python), `pymongo` (the official MongoDB driver for Python so we can interact with our database from our application), `openai` (so we can use OpenAI’s language models), `python-dotenv` (a library used to read key-value pairs from a .env file), and `tiktoken` (a package for token handling).  

### Environment configuration
Once this command has been run and our packages have been successfully downloaded, let’s configure our environment. Prior to doing this step, please ensure you have saved your OpenAI API key and your connection string from your MongoDB Atlas cluster in a `.env` file at the root of your project. Help on finding your MongoDB Atlas connection string can be found [in the docs](https://www.mongodb.com/pt-br/docs/guides/atlas/connection-string/).

```
import os
from dotenv import load_dotenv
from pymongo import MongoClient


load_dotenv(override=True)


# Add an environment file to the notebook root directory called .env with MONGO_URI="xxx" to load these environment variables


OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
MONGO_URI = os.environ["MONGO_URI"]
DB_NAME = "langchain-test-2"
COLLECTION_NAME = "test"
ATLAS_VECTOR_SEARCH_INDEX_NAME = "default"


EMBEDDING_FIELD_NAME = "embedding"
client = MongoClient(MONGO_URI)
db = client[DB_NAME]
collection = db[COLLECTION_NAME]
```

Please feel free to name your database, collection, and even your vector search index anything you like. Just continue to use the same names throughout the tutorial. The success of this code block ensures that both your database and collection are created in your MongoDB cluster. 

### Loading in our data
We are going to be loading in the `GPT-4 Technical Report` PDF. As mentioned above, this report came out after OpenAI’s ChatGPT information cutoff date, so the learning model isn’t trained to answer questions about the information included in this 100-page document. 

The LangChain package will help us answer any questions we have about this PDF. Let’s load in our data:

```
from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import MongoDBAtlasVectorSearch




loader = PyPDFLoader("https://arxiv.org/pdf/2303.08774.pdf")
data = loader.load()


text_splitter = RecursiveCharacterTextSplitter(chunk_size = 500, chunk_overlap = 50)
docs = text_splitter.split_documents(data)


# insert the documents in MongoDB Atlas Vector Search
x = MongoDBAtlasVectorSearch.from_documents(
documents=docs, embedding=OpenAIEmbeddings(disallowed_special=()), collection=MONGODB_COLLECTION, index_name=ATLAS_VECTOR_SEARCH_INDEX_NAME
)
```
In this code block, we are loading in our PDF, using a command to split up the data into various chunks, and then we are inserting the documents into our collection so we can use our search index on the inserted data. 

To test and make sure our data is properly loaded in, run a test: 
```
docs[0]
```
Your output should look like this:
![output from our docs[0] command to see if our data is loaded correctly](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltffc8c7af0758989d/65733c20c6be9382d6e0256f/lanchain1.png)

### Creating our search index
Let’s head over to our MongoDB Atlas user interface to create our Vector Search Index. 
First, click on the “Search” tab and then on “Create Search Index.” You’ll be taken to this page. Please click on “JSON Editor.” 

![click on JSON editor on screen](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt211855d86af82150/65a19c95a0eb302ea45007b6/Screenshot_2024-01-11_at_10.12.55_AM.png)

Please make sure the correct database and collection are pressed, and make sure you have the correct index name chosen that was defined above. Then, paste in the search index we are using for this tutorial:

```
{
  "fields": [
    {
      "type": "vector",
      "path": "embedding",  
      "numDimensions": 1536, 
      "similarity": "cosine"  
    },
    {
      "type": "filter",
      "path": "source"  
    }
   
  ]
}

```
These fields are to specify the field name in our documents. With `embedding`, we are specifying that the dimensions of the model used to embed are `1536`, and the similarity function used to find the nearest k neighbors is `cosine`. It’s crucial that the dimensions in our search index match that of the language model we are using to embed our data. 

Check out our [Vector Search documentation](https://www.mongodb.com/pt-br/docs/atlas/atlas-search/vector-search/) for more information on the index configuration settings.

Once set up, it’ll look like this:
![proper configuration of our vector search index](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt85334374e574511d/65a19d20fadb3a6d7ac3b15f/Screenshot_2024-01-12_at_3.12.05_PM.png)

Create the search index and let it load. 

## Querying our data
Now, we’re ready to query our data! We are going to show various ways of querying our data in this tutorial. We are going to utilize filters along with Vector Search to see our results. Let’s get started. Please ensure you are connected to your cluster prior to attempting to query or it will not work.

### Semantic search in LangChain
To get started, let’s first see an example using LangChain to perform a semantic search:

```
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import MongoDBAtlasVectorSearch


vector_search = MongoDBAtlasVectorSearch.from_connection_string(
   MONGO_URI,
   DB_NAME + "." + COLLECTION_NAME,
   OpenAIEmbeddings(disallowed_special=()),
   index_name=ATLAS_VECTOR_SEARCH_INDEX_NAME
)
query = "gpt-4"
results = vector_search.similarity_search(
   query=query,
   k=20,
)


for result in results:
   print( result)
```
This gives the output:
![output of LangChain semantic search](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt4654eb0d1827a60f/65734ad526253ceca5d09f5a/lanchani4.png)

This gives us the relevant results that semantically match the intent behind the question. Now, let’s see what happens when we ask a question using LangChain.

### Question and answering in LangChain
Run this code block to see what happens when we ask questions to see our results: 
```
qa_retriever = vector_search.as_retriever(
   search_type="similarity",
   search_kwargs={
       "k": 200,
       "post_filter_pipeline": [{"$limit": 25}]
   }
)
from langchain.prompts import PromptTemplate
prompt_template = """Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.


{context}


Question: {question}
"""
PROMPT = PromptTemplate(
   template=prompt_template, input_variables=["context", "question"]
)
from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI
from langchain.llms import OpenAI


qa = RetrievalQA.from_chain_type(llm=OpenAI(),chain_type="stuff", retriever=qa_retriever, return_source_documents=True, chain_type_kwargs={"prompt": PROMPT})


docs = qa({"query": "gpt-4 compute requirements"})


print(docs["result"])
print(docs['source_documents'])
```
After this is run, we get the result: 
```
GPT-4 requires a large amount of compute for training, it took 45 petaflops-days of compute to train the model. [Document(page_content='gpt3.5Figure 4. GPT performance on academic and professional exams. In each case, we simulate
```
This provides a succinct answer to our question, based on the data source provided. 

## Conclusion
Congratulations! You have successfully loaded in external data and queried it using LangChain and MongoDB. For more information on MongoDB Vector Search, please visit our [documentation](https://www.mongodb.com/products/platform/atlas-vector-search?utm_source=google&utm_campaign=search_gs_pl_evergreen_vector-stream_product_prosp-brand_gic-null_ww-multi_ps-all_desktop_eng_lead&utm_term=mongodb%20vector%20search&utm_medium=cpc_paid_search&utm_ad=e&utm_ad_campaign_id=20445624173&adgroup=155168612071&cq_cmp=20445624173&gad_source=1&gclid=Cj0KCQiAmNeqBhD4ARIsADsYfTfYLuAhm07D1f2_NrVXAWKnI5233Ytn5g3DJVzSvUYEeNWRRKV4B8AaAj2uEALw_wcB) 



This comprehensive tutorial takes you through how to integrate LangChain with MongoDB Atlas Vector Search.

Introduction to LangChain and MongoDB Atlas Vector Search

Tim Kelly

Developer Advocate

We are excited to announce native support for [MongoDB Atlas Vector Search](https://www.mongodb.com/products/platform/atlas-vector-search) in [Microsoft Semantic Kernel](https://learn.microsoft.com/en-us/semantic-kernel/overview/). With this integration, users can bring the power of LLMs (large language models) to their proprietary data securely, and build generative AI applications using RAG (retrieval-augmented generation) with programming languages like Python and C#. The accompanying tutorial will walk you through an example.

## What is Semantic Kernel?
Semantic Kernel is a polyglot, open-source SDK that lets users combine various AI services with their applications. Semantic Kernel uses connectors to allow you to swap out AI services without rewriting code. Components of Semantic Kernel include: 

 - AI services: Supports AI services like OpenAI, Azure OpenAI, and Hugging Face. 
 - Programming languages: Supports conventional programming languages like C# Python, and Java.
 - Large language model (LLM) prompts: Supports the latest in LLM AI prompts with prompt templating, chaining, and planning capabilities. 
 - Memory: Provides different vectorized stores for storing data, including MongoDB.

## What is MongoDB Atlas Vector Search?
MongoDB Atlas Vector Search is a fully managed service that simplifies the process of effectively indexing high-dimensional vector embedding data within MongoDB and being able to perform fast vector similarity searches. 

Embedding refers to the representation of words, phrases, or other entities as dense vectors in a continuous vector space. It's designed to ensure that words with similar meanings are grouped closer together. This method helps computer models better understand and process language by recognizing patterns and relationships between words and is what allows us to search by semantic meaning.

When data is converted into numeric vector embeddings using encoding models, these embeddings can be stored directly alongside their respective source data within the MongoDB database. This co-location of vector embeddings and the original data not only enhances the efficiency of queries but also eliminates potential synchronization issues. By avoiding the need to maintain separate databases or synchronization processes for the source data and its embeddings, MongoDB provides a seamless and integrated data retrieval experience.

This consolidated approach streamlines database management and allows for intuitive and sophisticated semantic searches, making the integration of AI-powered experiences easier.

## Microsoft Semantic Kernel and MongoDB
This combination enables developers to build AI-powered intelligent applications using MongoDB Atlas Vector Search and large language models from providers like OpenAI, Azure OpenAI, and Hugging Face. 

Despite all their incredible capabilities, LLMs have a knowledge cutoff date and often need to be augmented with proprietary, up-to-date information for the particular business that an application is being built for. This “long-term memory for LLM” capability for AI-powered intelligent applications is typically powered by leveraging [vector embeddings](https://www.mongodb.com/pt-br/developer/products/atlas/building-generative-ai-applications-vector-search-open-source-models/). Semantic Kernel allows for storing and retrieving this vector context for AI apps using the memory plugin (which now has support for MongoDB Atlas Vector Search). 

## Tutorial
[Atlas Vector Search](https://www.mongodb.com/products/platform/atlas-vector-search) is integrated in this tutorial to provide a way to interact with our memory store that was created through our MongoDB and Semantic Kernel [connector](https://github.com/microsoft/semantic-kernel/tree/main/python/semantic_kernel/connectors/memory/mongodb_atlas).

This tutorial takes you through how to use Microsoft Semantic Kernel to properly upload and embed documents into your MongoDB Atlas cluster, and then conduct queries using Microsoft Semantic Kernel as well, all in Python!

## Pre-requisites 

 - [MongoDB Atlas cluster](https://www.mongodb.com/pt-br/docs/atlas/getting-started/) 
 - IDE of your choice (this tutorial uses [Google Colab](https://colab.research.google.com/drive/1Qlgor8-nFEkugMdTADYVKIYZejSAWQUV#scrollTo=U8u9vfQYnWvt) — please refer to it if you’d like to run the commands directly)
 - [OpenAI API key](https://platform.openai.com/docs/introduction)

Let’s get started!

## Setting up our Atlas cluster
Visit the [MongoDB Atlas](https://account.mongodb.com/account/login) dashboard and set up your cluster. In order to take advantage of the `$vectorSearch` operator in an aggregation pipeline, you need to run MongoDB Atlas 6.0.11 or higher. This tutorial can be built using a free cluster. 

When you’re setting up your deployment, you’ll be prompted to set up a database user and rules for your network connection. Please ensure you save your username and password somewhere safe and have the correct IP address rules in place so your cluster can connect properly. 

If you need more help getting started, check out our [tutorial on MongoDB Atlas](https://www.mongodb.com/basics/mongodb-atlas-tutorial). 

## Installing the latest version of Semantic Kernel
In order to be successful with our tutorial, let’s ensure we have the most up-to-date version of Semantic Kernel installed in our IDE. As of the creation of this tutorial, the latest version is 0.3.14. Please run this `pip` command in your IDE to get started:
```
!python -m pip install semantic-kernel==0.3.14.dev
```
Once it has been successfully run, you will see various packages being downloaded. Please ensure `pymongo` is downloaded in this list. 

## Setting up our imports 
Here, include the information about our OpenAI API key and our connection string. 

Let’s set up the necessary imports:
```
import openai
import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion, OpenAITextEmbedding
from semantic_kernel.connectors.memory.mongodb_atlas import MongoDBAtlasMemoryStore



kernel = sk.Kernel()


openai.api_key = '<your-openai-key'
MONGODB_SEARCH_INDEX="defaultRandomFacts"
MONGODB_DATABASE="semantic-kernel"
MONGODB_COLLECTION="randomFacts"


kernel.add_chat_service("chat-gpt", OpenAIChatCompletion("gpt-3.5-turbo", openai.api_key))
kernel.add_text_embedding_generation_service("ada", OpenAITextEmbedding("text-embedding-ada-002", openai.api_key))


kernel.register_memory_store(memory_store=MongoDBAtlasMemoryStore(index_name=MONGODB_SEARCH_INDEX, database_name=MONGODB_DATABASE, connection_string="<mongodb-uri>"))
kernel.import_skill(sk.core_skills.TextMemorySkill())
```
Importing in OpenAI is crucial because we are using their data model to embed not only our documents but also our queries. We also want to import their Text Embedding library for this same reason. For this tutorial, we are using the embedding model `ada-002`, but please double check that you’re using a model that is compatible with your OpenAI API key.

Our `MongoDBAtlasMemoryStore` class is very important as it’s the part that enables us to use MongoDB as our memory store. This means we can connect to the Semantic Kernel and have our documents properly saved and formatted in our cluster. For more information on this class, please refer to the [repository](https://github.com/microsoft/semantic-kernel/tree/main/python/semantic_kernel/connectors/memory/mongodb_atlas). 

This is also where you will need to incorporate your OpenAI API key along with your [MongoDB connection string](https://www.mongodb.com/pt-br/docs/atlas/), and other important variables that we will use. The ones above are just a suggestion, but if they are changed while attempting the tutorial, please ensure they are consistent throughout. For help on accessing your OpenAI key, please read the section below.

### Generate your OpenAI key
In order to generate our embeddings, we will use the OpenAI API. First, we’ll need a secret key. To create your OpenAI key, you'll need to create an account. Once you have that, visit the [OpenAI API](https://platform.openai.com/) and you should be greeted with a screen like the one below. Click on your profile icon in the top right of the screen to get the dropdown menu and select “View API keys”.
![where to find your API key on OpenAI](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltbb8293d6a59ed869/65568a482e0ea1959117960a/semantickernela1.png)

Here, you can generate your own API key by clicking the “Create new secret key” button. Give it a name and store it somewhere safe. This is all you need from OpenAI to use their API to generate your embeddings.

![how to create a new API key](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt1550895c161b4e43/65568a9b4452cc73ecf967a6/semantickernela2.png)

## The need for retrieval-augmented generation (RAG)
Retrieval-augmented regeneration, also known as RAG, is an NLP technique that can help improve the quality of large language models (LLMs). It’s an artificial intelligence framework for getting data from an external knowledge source. The memory store we are creating using Microsoft Semantic Kernel is an example of this. But why is RAG necessary? Let’s take a look at an example.

LLMs like OpenAI GPT-3.5 exhibit an impressive and wide range of skills. They are trained on the data available on the internet about a wide range of topics and can answer queries accurately. Using Semantic Kernel, let’s ask OpenAI’s LLM if Albert Einstein likes coffee: 
```
# Wrap your prompt in a function
prompt = kernel.create_semantic_function("""
As a friendly AI Copilot, answer the question: Did Albert Einstein like coffee?
""")


print(prompt())
```
The output received is:
```
Yes, Albert Einstein was known to enjoy coffee. He was often seen with a cup of coffee in his hand and would frequently visit cafes to discuss scientific ideas with his colleagues over a cup of coffee.
```
Since this information was available on the public internet, the LLM was able to provide the correct answer.

But LLMs have their limitations: They have a knowledge cutoff (September 2021, in the case of OpenAI) and do not know about proprietary and personal data. They also have a tendency to hallucinate — that is, they may confidently make up facts and provide answers that may seem to be accurate but are actually incorrect. Here is an example to demonstrate this knowledge gap:

```
prompt = kernel.create_semantic_function("""
As a friendly AI Copilot, answer the question: Did I like coffee?
""")


print(prompt())
```
The output received is:
```
As an AI, I don't have personal preferences or experiences, so I can't say whether "I" liked coffee or not. However, coffee is a popular beverage enjoyed by many people around the world. It has a distinct taste and aroma that some people find appealing, while others may not enjoy it as much. Ultimately, whether someone likes coffee or not is a subjective matter and varies from person to person.
``` 

As you can see, there is a knowledge gap here because we don’t have our personal data loaded in OpenAI that our query can access. So let’s change that. Continue on through the tutorial to learn how to augment the knowledge base of the LLM with proprietary data. 

## Add some documents into our MongoDB cluster
Once we have incorporated our MongoDB connection string and our OpenAI API key, we are ready to add some documents into our MongoDB cluster. 

Please ensure you’re specifying the proper collection variable below that we set up above. 
```
async def populate_memory(kernel: sk.Kernel) -> None:
# Add some documents to the semantic memory
await kernel.memory.save_information_async(
collection=MONGODB_COLLECTION, id="1", text="We enjoy coffee and Starbucks"
)
await kernel.memory.save_information_async(
collection=MONGODB_COLLECTION, id="2", text="We are Associate Developer Advocates at MongoDB"
)
await kernel.memory.save_information_async(
collection=MONGODB_COLLECTION, id="3", text="We have great coworkers and we love our teams!"
)
await kernel.memory.save_information_async(
collection=MONGODB_COLLECTION, id="4", text="Our names are Anaiya and Tim"
)
await kernel.memory.save_information_async(
collection=MONGODB_COLLECTION, id="5", text="We have been to New York City and Dublin"
)
```
Here, we are using the `populate_memory` function to define five documents with various facts about Anaiya and Tim. As you can see, the name of our collection is called “randomFacts”, we have specified the ID for each document (please ensure each ID is unique, otherwise you will get an error), and then we have included a text phrase we want to embed. 

Once you have successfully filled in your information and have run this command, let’s add them to our cluster — aka let’s populate our memory! To do this, please run the command:
```
print("Populating memory...aka adding in documents")
await populate_memory(kernel)
```
Once this command has been successfully run, you should see the database, collection, documents, and their embeddings populate in your Atlas cluster. The screenshot below shows how the first document looks after running these commands.

![screenshot of our first document with the text embedding](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt0a505f52e4d85526/65568b25a255e23bc9211f7a/semantickernela3.png)
  
Once the documents added to our memory have their embeddings, let’s set up our search index and ensure we can generate embeddings for our queries. 

## Create a vector search index in MongoDB 
In order to use the `$vectorSearch` operator on our data, we need to set up an appropriate search index. We’ll do this in the [Atlas UI](https://account.mongodb.com/account/login). Select the “Search" tab on your cluster and click “Create Search Index”.
![where to create a vector search index](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt4fb2a898919fdbc2/65568b844e0195c4c3bf1f64/semantickernela4.png)

We want to choose the "JSON Editor Option" and click "Next".

![specifics for creating a search index](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt33055bae582002e4/655bb51b3133dbdcc8911770/semantickernel5.png)

On this page, we're going to select our target database, `semantic-kernel`, and collection, `randomFacts`.

For this tutorial, we are naming our index `defaultRandomFacts`. The index will look like this: 

```json
{
  "mappings": {
    "dynamic": true,
    "fields": {
      "embedding": {
        "dimensions": 1536,
        "similarity": "dotProduct",
        "type": "knnVector"
      }
    }
  }
}
```
The fields specify the embedding field name in our documents, `embedding`, the dimensions of the model used to embed, `1536`, and the similarity function to use to find K-nearest neighbors, `dotProduct`. It's very important that the dimensions in the index match that of the model used for embedding. This data has been embedded using the same model as the one we'll be using, but other models are available and may use different dimensions.

Check out our [Vector Search documentation](https://www.mongodb.com/pt-br/docs/atlas/atlas-search/vector-search/) for more information on the index configuration settings.

## Query documents using Microsoft Semantic Kernel
In order to query your new documents hosted in your MongoDB cluster “memory” store, we can use the `memory.search_async` function. Run the following commands and watch the magic happen:

```
result = await kernel.memory.search_async(MONGODB_COLLECTION, 'What is my job title?')


print(f"Retrieved document: {result[0].text}, {result[0].relevance}")
```

Now you can ask any question and get an accurate response!  

Examples of questions asked and the results: 
![the result of the question: What is my job title?](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltb0ffef5ac86f7f5c/655bb5826f7bf46d9a82c7fe/semantickernel6.png)

![the result of the question: Do I like caffeine?](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt4dcf417349dfc947/655bb5b4867c0b640138726c/semantickernel7.png)

![the result of the question: Where in the world have I visited?](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt3f87d869993ff195/655bb5e17c56dde9cba5dcac/semantickernel8.png)

## Conclusion
In this tutorial, you have learned a lot of very useful concepts:

 - What Microsoft Semantic Kernel is and why it’s important.
 - How to connect Microsoft Semantic Kernel to a MongoDB Atlas cluster.
 - How to add in documents to your MongoDB memory store (and embed them, in the process, through Microsoft Semantic Kernel).
 - How to query your new documents in your memory store using Microsoft Semantic Kernel.

For more information on MongoDB Vector Search, please visit the [documentation](https://www.mongodb.com/products/platform/atlas-vector-search), and for more information on Microsoft Semantic Kernel, please visit their [repository](https://github.com/microsoft/semantic-kernel) and [resources](https://learn.microsoft.com/en-us/semantic-kernel/overview/). 

If you have any questions, please visit our [MongoDB Developer Community Forum](https://www.mongodb.com/community/forums/). 

Follow this comprehensive guide to getting started with Microsoft Semantic Kernel and MongoDB Atlas Vector Search.

Prakul Agarwal

Conteúdo por Prakul Agarwal

Criação de aplicativos de IA generativa usando o MongoDB: aproveitando o poder do Atlas Vector Search e dos modelos de código aberto

Avaliação RAG: detectando alucinações com Patronus AI e MongoDB

Introdução ao LangChain e ao Atlas Vector Search do MongoDB Atlas

Criando aplicações de IA com o Microsoft Semantic Kernel e o MongoDB Atlas Vector Search