Igor Alekseev

Partner Solutions Architect, Data & Analytics

Venkatesh Shanbhag

Partner Solution Architect

MongoDB

Mohammad Daoud Farooqi

Partner Solutions Architect

# Creating a Memory-Enhanced AI Agent with Anthropic's Claude in Amazon Bedrock with MongoDB Atlas

What if we could build a knowledge-based system designed to provide personalized information and answer user queries? And do this by leveraging a robust search architecture that efficiently handles both simple keyword-based queries and complex conversational inquiries. Consider a use case for a travel advisory service that offers personalized recommendations and answers questions related to travel itineraries and planning. By combining advanced search techniques with natural language understanding, this system would deliver accurate and informative responses tailored to individual user needs. Such a system can be seen as an agent—a computational entity capable of understanding its environment, perceiving input, taking actions through tool utilization, and using cognition supported by foundation models. These agents, equipped with short-term and long-term memory, are sophisticated AI entities that make intelligent decisions and execute actions based on environmental awareness.Let's have a look at some examples.

![Figure 1: Conversation between Travel Agent Chatbot and User, utilizing keywords to perform an exact match search][1]

Figure 1: Conversation between Travel Agent Chatbot and User, utilizing keywords to perform an exact match search.

In this example, the Large Language Model (LLM) – Anthropic’s Claude –  leverages MongoDB Query Language (MQL) functions as specialized tools to directly search and retrieve results based on user queries. By utilizing MQL’s structured query capabilities, the LLM efficiently navigates databases, executing precise queries tailored to the user’s needs. This approach ensures contextually accurate responses while optimizing performance by reducing unnecessary processing time. The integration of MQL allows the LLM to handle complex queries and large datasets with precision, demonstrating the powerful synergy between AI-driven natural language understanding and advanced data retrieval techniques in MongoDB.

![Conversation between Travel Agent Chatbot and User, utilizing MongoDB’s Vector Semantic Search without relying on specific keywords][2]

Figure 2: Conversation between Travel Agent Chatbot and User, utilizing MongoDB’s Vector Semantic Search without relying on specific keywords.

In this example interaction, the LLM utilizes MongoDB's Vector Search functionality, defined as a specialized tool, along with the user's conversation history, to extract all previously suggested locations to visit. By employing this advanced vector search, the LLM Agent efficiently analyzes the data and retrieves the best-rated recommendation based on contextual relevance and user preferences.

MongoDB Vector Search enables the LLM to go beyond traditional keyword-based searching by leveraging embeddings and semantic understanding to evaluate the quality and relevance of the locations in the conversation history. This allows for more intelligent and nuanced data retrieval, ensuring that the response is not only accurate but also tailored to the user’s needs.

By combining the power of MongoDB's Vector Search with contextual data, the LLM Agent demonstrates advanced capabilities in querying large datasets, identifying patterns, and ranking results. This approach showcases the power of integrating AI-driven natural language processing with modern database technologies like MongoDB Vector Search to provide users with more precise, contextually aware, and high-value responses with robust data processing.

**#Note:** In this implementation, the AI Agent is prompted to explain which tools were utilized to generate the final response. In a real-world application, the response would be concise and directly address the user's queries.

In the above scenario, user queries fall into two main types: simple match queries using specific keywords like location, country, or destination name, and conversational queries seeking more detailed information about a place. A [Retrieval-Augmented Generation (RAG)](https://aws.amazon.com/what-is/retrieval-augmented-generation/#:~:text=Augmented%20Generation%20requirements?-,What%20is%20Retrieval%2DAugmented%20Generation?,and%20useful%20in%20various%20contexts.) system, which combines information retrieval with generative models, can handle both types effectively. RAG retrieves relevant information from a database and then generates a coherent response. While building a RAG, embedding the entire user query can be redundant or inefficient in some scenarios where the data is in structured format. For simple keyword-based queries, direct matches are sufficient. While more complex conversational queries are better served by semantic search, providing deeper contextual understanding.


## Solution Architecture

The application stack is built on AWS. The core logic runs on AWS Lambda, connecting to Amazon Bedrock and MongoDB Atlas. Lambda uses Anthropic’s Claude in Amazon Bedrock to generate embeddings and make decisions about whether to use direct lookups or semantic search in MongoDB Atlas. Users interact with our application through Amazon Lex, which provides a natural language interface.

![Architecture diagram illustrating the integration of AWS, Anthropic, and MongoDB for building an AI-enhanced end-to-end application][3]

Figure 3: Architecture diagram illustrating the integration of AWS, Anthropic, and MongoDB for building an AI-enhanced end-to-end application.

* AWS Bedrock (Model hosting) 

    [AWS Bedrock](https://aws.amazon.com/bedrock/) will play a critical role in hosting and orchestrating the Anthropic models and Titan embedding models, providing a robust foundation for model management and execution. Bedrock's scalable infrastructure will ensure the seamless operation of the AI models, allowing for quick processing of large datasets and ensuring the responsiveness of the system under varying workloads. Its managed services approach simplifies the integration and operational complexities of running Anthropic models at scale.

* Anthropic’s Claude  (Large Language Model) 

    [Anthropic](https://www.anthropic.com/)'s Claude models enhance the quality and richness of the data stored in MongoDB Atlas. Claude will provides deeper insights and smarter recommendations by analyzing patterns within the trip data and the stored embeddings. By augmenting the database with AI-driven enhancements, Claude models  ensure more accurate and contextually relevant results for users.

* MongoDB Atlas (Data store)

    [MongoDB Atlas](https://www.mongodb.com/products/platform/atlas-cloud-providers/aws?utm_source=google&utm_campaign=search_gs_pl_evergreen_atlas_general_prosp-brand_gic-null_apac-in_ps-all_desktop_eng_lead&utm_term=mongodb%20atlas%20on%20aws&utm_medium=cpc_paid_search&utm_ad=e&utm_ad_campaign_id=6501677905&adgroup=84316982601&cq_cmp=6501677905&gad_source=1&gclid=Cj0KCQjwxsm3BhDrARIsAMtVz6P5w-mog6aBGE4-S2MP-8EwanYdygoOMHwpdCCl8kUNlMZjgUmOpesaAu_eEALw_wcB) will serve as the primary database, responsible for securely storing structured and unstructured trip recommendation data. Additionally, it will house embeddings and chat history that are essential for advanced search and recommendation features, enabling more relevant and personalized travel suggestions. With its cloud-native design, Atlas ensures scalability, high availability, and seamless integration with other components in the architecture.

![MongoDB Atlas provides long-term memory, vector embedding retrieval, and semantic search capabilities, enabling the agent to efficiently manage and retrieve conversational data][4]

Figure 4: MongoDB Atlas provides long-term memory, vector embedding retrieval, and semantic search capabilities, enabling the agent to efficiently manage and retrieve conversational data.


* Lambda (Application backend)

    [AWS Lambda](https://aws.amazon.com/pm/lambda/) will be utilized to deploy and run the backend application, offering a serverless architecture that automatically scales based on demand. The backend will handle various business logic, from processing requests to interacting with MongoDB Atlas and AWS Bedrock. Lambda's event-driven model reduces infrastructure management overhead, enabling efficient, cost-effective, and flexible application deployment.

* Lex (Conversational User Interface)

    [AWS Lex](https://aws.amazon.com/pm/lex) will be employed to create an intuitive user interface, offering natural language processing capabilities to enhance user interaction.

![User journey on lex for the application flow][5]

Figure 5: User journey on lex for the application flow.


## Implementation 

Let us look at how this application architecture has been implemented for this exercise. In order to perform a match query against MongoDB, the [Langchain Agent](https://python.langchain.com/v0.1/docs/modules/agents/) uses the following functions as tools. LangChain agents are AI components that use language models to choose a sequence of actions to take. Whereas MongoDB integrates the operational database and vector search in a single, unified, fully managed platform with full vector database capabilities. It stores users' operational data, metadata, and vector embeddings on Atlas while using Atlas Vector Search to build intelligent gen AI-powered applications.

For this blog we are showcasing only a few sample snippets to illustrate the user journey through the application. The whole code is available in the [Github repository](https://github.com/mongodb-partners/QS-Anthropic-1).


#### **1. Direct MongoDB Query**

A user wants to interact with a travel agent and search for a specific place by name. The following function can perform a basic MongoDB search on a travel dataset. It retrieves place names by matching a provided country name, using a case-insensitive regular expression ($regex) to search for documents where the "Country" field matches the query_str. The function then returns the "Place Name" field from the matched documents.

```python
       def mongodb_place_lookup_by_country(query_str: str) -> str:
       """Retrieve place by Country Name"""
       res = ""
       res = collection.aggregate(
           [
               {"$match": {"Country": {"$regex": query_str, "$options": "i"}}},
               {"$project": {"Place Name": 1}},
           ]
       )
       places = []
       for place in res:
           places.append(place["Place Name"])
       return str(places)
```

We’ve created two additional functions that work similarly for retrieving specific fields like "Place Name" and "Best Time To Visit" or get complete place details based on your search criteria. All these functions use case-insensitive regular expressions for flexible matching.

If the query does not have any keywords to perform a direct match the LangChain agent will perform MongoDB vector search.


#### **2. MongoDB Vector Search**

The Langchain Agent performs MongoDB vector search when the user's query lacks a specific keyword for conducting a direct search on MongoDB.

```python
    # filter the data using the criteria and do a Schematic search
    def mongodb_search(query: str) -> str:
       """Retrieve results from MongoDB related to the user input by performing vector search. Pass text input only."""
       embeddings = BedrockEmbeddings(
           client=bedrock_runtime,
           model_id=embedding_model_id,
       )
       text_as_embeddings = embeddings.embed_documents([query])
       embedding_value = text_as_embeddings[0]
    
    
       # get the vector search results based on the filter conditions.
       response = collection.aggregate(
           [
               {
                   "$vectorSearch": {
                       "index": "awsanthropic_vector_index",
                       "path": "details_embedding",
                       "queryVector": embedding_value,
                       "numCandidates": 200,
                       "limit": 10,
                   }
               },
               {
                   "$project": {
                       "score": {"$meta": "searchScore"},
                       field_name_to_be_vectorized: 1,
                       "_id": 0,
                   }
               },
           ]
       )
    
    
       # Result is a list of docs with the array fields
       docs = list(response)
    
    
       # Extract an array field from the docs
       array_field = [doc[field_name_to_be_vectorized] for doc in docs]
    
    
       # Join array elements into a string
       llm_input_text = "\n \n".join(str(elem) for elem in array_field)
    
    
       # utility
       newline, bold, unbold = "\n", "\033[1m", "\033[0m"
       logging.info(
           newline
           + bold
           + "Given Input From MongoDB Vector Search: "
           + unbold
           + newline
           + llm_input_text
           + newline
       )
    
    
       return llm_input_text
```

Anthropic’s Claude hosted in Amazon Bedrock glues it together by choosing the best matching tools to perform search on MongoDB Atlas based on the user query.It improves the experience by presenting the output in a human-friendly format. The following functions initialize the LLM and add the MongoDB python functions as tools to the Agent. It also stores the conversation history to MongoDB Atlas.

```python
    def get_session_history(session_id: str) -> MongoDBChatMessageHistory:
       return MongoDBChatMessageHistory(
           utils.get_MongoDB_Uri(),
           session_id,
           database_name="anthropic-travel-agency",
           collection_name="chat_history",
       )
    
    
    
    
    def interact_with_agent(sessionId, input_query, chat_history):
       """Interact with the agent and store chat history. Return the response."""
    
    
       # Initialize bedrock and llm
       bedrock_runtime = setup_bedrock()
       llm = initialize_llm(bedrock_runtime)
    
    
       # Initialize tools
       tool_mongodb_search = StructuredTool.from_function(mongodb_search)
       tool_mongodb_place_lookup_by_country = StructuredTool.from_function(
           mongodb_place_lookup_by_country
       )
       tool_mongodb_place_lookup_by_name = StructuredTool.from_function(
           mongodb_place_lookup_by_name
       )
       tool_mongodb_place_lookup_by_best_time_to_visit = StructuredTool.from_function(
           mongodb_place_lookup_by_best_time_to_visit
       )
    
    
       tools = [
           tool_mongodb_search,
           tool_mongodb_place_lookup_by_country,
           tool_mongodb_place_lookup_by_name,
           tool_mongodb_place_lookup_by_best_time_to_visit,
       ]
    
    
       chat_message_int = MessagesPlaceholder(variable_name="chat_history")
    
    
       memory = ConversationBufferMemory(
           memory_key="chat_history",
           chat_memory=get_session_history(sessionId),
           return_messages=True,
       )
    
    
       PREFIX = """You are a helpful and polite Travel recommendations assistant. Answer the following questions as best you can using only the provided tools and chat history. You have access to the following tools:"""
       FORMAT_INSTRUCTIONS = """Always return only the final answer to the original input question in human readable format as text only without any extra special characters. Also tell all the tools you used to reach to this answer in brief."""
       SUFFIX = """Begin!"""
    
    
       agent_executor = initialize_agent(
           tools,
           llm,
           agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
           agent_kwargs={
               "memory_prompts": [chat_message_int],
               "input_variables": ["input", "agent_scratchpad", "chat_history"],
               "prefix":PREFIX,
               "format_instructions":FORMAT_INSTRUCTIONS,
               "suffix":SUFFIX
           },
           memory=memory,
           verbose=True,
           max_iterations=3
       )
       result = agent_executor.invoke(
           {
               "input": input_query,
               "chat_history": chat_history,
           }
       )
       chat_history.append(HumanMessage(content=input_query))
       chat_history.append(AIMessage(content="Assistant: " + result["output"]))
       return result
```

We can deploy the travel agency chatbot app on AWS Lambda using [SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html). The application can be tested by creating a Bot on Amazon Lex. To add the bot to the Amazon Connect, navigate to your Amazon Connect Instance and then navigate to Flows. Select the Lex bot that you want to use. 

![Select the Lex bot that you want to use][6]


To use the bot in an Amazon Connect flow add Get User Input Block. In the Block details add select Amazon Lex Bot:

![Select Amazon Lex Bot][7]

For more information on adding Amazon Lex bots to Amazon Connect refer to the [documentation](https://docs.aws.amazon.com/connect/latest/adminguide/amazon-lex.html). To learn more about how to set up the Application and test out the functionalities refer to the [Github](https://github.com/mongodb-partners/QS-Anthropic-1). 


## Conclusion

In this blog, we explored how Anthropic's Claude in Amazon Bedrock with MongoDB Atlas can be leveraged to build and deploy an Agentic RAG application. The resulting application is a memory-enhanced AI agent that provides personalized travel recommendations. This architecture efficiently manages both simple and complex queries, delivering accurate, user-friendly responses while ensuring a smooth and seamless conversational experience.


## Also Read

1. [The MongoDB AI Applications Program (MAAP)](https://www.mongodb.com/services/consulting/ai-applications-program) helps organizations rapidly build and deploy modern applications enriched with AI technology at enterprise scale.
2. Try out MongoDB on [AWS Marketplace](https://aws.amazon.com/marketplace/seller-profile?id=c9032c7b-70dd-459f-834f-c1e23cf3d092).

  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt3a75ae5cb39d68e8/66fc790cb316ce784ae6a9cd/image1.png
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt77d9909edde0845b/66fc790cc235b3405a10359b/image2.png
  [3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt84b5ef25e4b43278/66fc790c3804eb32ecb207bc/image3.png
  [4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt814f31401d48733d/66fc790c11f4cc7937a251ed/image4.png
  [5]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt624a2287afac9280/66fc790cf32d3711d8a08c08/image5.png
  [6]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltce5e9be3f4cc97ae/66fc790ce1f0eb557b595e90/image6.png
  [7]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt51c260291162913a/66fc790c3804eb99a4b207b8/image7.png



What if we could build a knowledge-based system designed to provide personalized information and answer user queries? And do this by leveraging a robust search architecture that efficiently handles both simple keyword-based queries and complex conversational inquiries? We can with Memory-Enhanced AI Agents powered by AWS, Anthropic and MongoDB

Mohammad Daoud Farooqi

Content by Mohammad Daoud Farooqi

Creating a Memory-Enhanced AI Agent with Anthropic's Claude in Amazon Bedrock with MongoDB Atlas