Artificial intelligence is moving beyond simple chatbots and question-answering systems toward AI agents that can understand a request, reason about what needs to happen, access business data, use tools, and take actions on behalf of users. For organizations building these systems on AWS, Amazon Bedrock and Amazon DynamoDB can form an effective foundation for creating scalable, data-aware AI agent architectures.
Amazon Bedrock provides access to foundation models and agent capabilities, while DynamoDB can store operational application data, conversation information, and, with its vector search capabilities, support semantic retrieval. AWS has also demonstrated architectures in which Bedrock agents use Lambda action groups to interact with DynamoDB for both structured lookups and semantic search. This article explains how an AI agent architecture with DynamoDB and Bedrock works, the role of each component, how requests flow through the system, important design considerations, and where this architecture can be useful.
Introducing AI Agent
An AI agent is a software system that uses a foundation model to interpret user instructions and determine the actions required to complete a task.
Unlike a conventional chatbot that primarily generates text, an agent can connect a model to external tools and data sources. For example, a customer-support agent could receive a request such as:
“Find my latest order and tell me whether it will arrive tomorrow.”
The agent may need to identify the customer, query an operational database, interpret delivery information, and formulate a response. The foundation model does the language understanding and reasoning, and the application services do the actual data retrieval or business operations. Amazon Bedrock supports agent-based applications by allowing foundation models to work with action groups and external resources. AWS has previously demonstrated Bedrock agents working with DynamoDB, Lambda, and other AWS services for customized responses and data retrieval.
Why Combine DynamoDB and Amazon Bedrock?
The combination is useful because the two services solve different parts of the architecture.
Amazon Bedrock provides the intelligence layer. This allows applications to consume foundation models without having to build and maintain their own model infrastructure. Amazon DynamoDB offers a highly scalable NoSQL data layer for application and operational data. It can store things like customer profiles, orders, product information, session data, agent state and other application specific information. Modern DynamoDB capabilities can also support vector search. AWS's current reference architecture demonstrates a unified design where DynamoDB stores both operational records and vector embeddings, allowing an application to combine structured lookups with semantic search.
This creates an architecture in which an AI agent can potentially answer both:
“Show me order #48291.”
and:
“Find products similar to this description.”
without necessarily introducing a separate vector database.
Core Architecture of an AI Agent with DynamoDB and Bedrock
A typical architecture can contain the following layers:
User → Application/API → Amazon Bedrock Agent → Lambda Action Group → DynamoDB → Response
Additional AWS services can be introduced depending on the application's requirements.
1. User Interaction Layer
The process is triggered when a user interacts with the application. This may be a website, mobile application, internal enterprise portal, customer-support interface, or voice-enabled application. The user may ask: “Show me my recent transactions.” The application sends this query to the backend, where authentication and authorization can be handled before the request reaches the AI agent. This layer should also establish the user’s identity or tenant context. That information becomes especially important when the agent accesses customer-specific DynamoDB records.
2. Amazon Bedrock as the Intelligence Layer
Amazon Bedrock provides access to foundation models through managed APIs and supports development of generative AI applications. In an agent architecture, the model receives the user’s query and then determines what information or action is needed; for example, if the user asks “What laptop should I consider based on my previous purchases?” then the agent might determine it needs some historical purchase information before it can answer, and rather than make up the information, the agent can invoke a well-defined action to retrieve relevant records from DynamoDB.This separation of reasoning and execution is one of the most important architectural principles for building reliable AI agents.
The model decides what needs to happen, while application code controls how that operation actually happens.
3. Bedrock Agent Action Groups
Action groups provide a mechanism for connecting an agent with external functions.
A common implementation uses AWS Lambda as the action-group handler. For example, an action group could expose functions such as:
get_customer
get_order
search_products
get_product_details
search_knowledge
update_order
When the model determines that one of these capabilities is required, the Bedrock agent can invoke the corresponding action.
AWS's reference architecture uses a Lambda action group to handle both semantic search and operational lookups against DynamoDB.It also provides a clean separation of AI model and back-end systems for the developers.
4. Lambda as the Tool Execution Layer
We can use Lambda as a middle layer between the Bedrock agent and DynamoDB. For example, we can define an action group like below: { "function": "get_order", "parameters": { "order_id": "48291" } }. The Lambda function will validate the request, perform the required DB operation and return well-formed output. The output data can be like: { "order_id": "48291", "status": "Shipped", "estimated_delivery": "2026-09-23" }. The Bedrock agent can use this data to construct a natural language response.
Lambda is meant to be used for application level rules, not to open the database to an AI model.
5. DynamoDB as the Operational Data Store
When an AI application requires fast access to structured application data, DynamoDB is a good choice. For example, data for an AI customer support system may include Customer ID, Order ID, Product ID, Order Status, Payment Status, Shipping Status, Client Preferences and Conversation Metadata. Example:
Data Type | Example |
Customer | Customer profile |
Order | Order status and delivery information |
Product | Product specifications |
Session | Conversation/session information |
Preferences | User-specific preferences |
Knowledge | Searchable content metadata |
The agent accesses these records via controlled application functions. That is, the AI system can base its responses on current application data and not only data learned during model training.
6. Adding Vector Search to DynamoDB
One of the more interesting developments in this architecture is the ability to combine operational data and semantic search.
Traditional database queries typically rely on exact or structured conditions.
For example:
category = "laptops"
price < 1000
brand = "Dell"
Semantic search works differently.
A user might ask:
“Find lightweight laptops suitable for frequent business travel.”
The system can convert the query into an embedding and compare it with embeddings stored in a vector index.
AWS's current unified AI agent architecture demonstrates using DynamoDB vector search alongside operational data in the same broader architecture. The reference implementation uses embeddings generated through Amazon Bedrock and stores them for semantic retrieval.
Benefits of the Architecture
An AI agent architecture built on DynamoDB and Bedrock can offer several practical benefits.
Lower Infrastructure Complexity
For existing DynamoDB users, adding vector capabilities helps you avoid a second database for some semantic-search workloads.
Real-time Business Data Access
The agent can query information directly from operational systems, not just from model knowledge.
Flexible Architecture
Bedrock offers managed access to foundation models and DynamoDB was built to support scalable application workloads.
Tool-Based Control
Lambda action groups create a controlled interface between the AI agent and backend services.
Flexible Search
Applications can combine structured lookups with semantic retrieval depending on the user request.
AWS specifically identifies this unified pattern as useful when documents change frequently, need to become searchable quickly, and the dataset fits DynamoDB's vector-search constraints.
When DynamoDB May Not Be Enough
Although this architecture is powerful, DynamoDB should not automatically be selected for every AI search workload.
If your source data resides primarily in Amazon S3 and you’re looking for managed ingestion and chunking, then consider Amazon Bedrock Knowledge Bases, which AWS recommends.If your application needs more sophisticated search features like aggregations, faceted search, or complex filtering, consider Amazon OpenSearch Service. The right architecture depends on variables such as the volume of data, the search requirements, the update frequency, the latency needs, the security boundaries, and your existing AWS infrastructure.
Future of AI Agent Architecture on AWS
AI agents are increasingly becoming an orchestration layer between users, foundation models, business applications, and enterprise data.
The architecture does not have to stop at DynamoDB and Bedrock. Depending on the use case, agents can connect with APIs, event-driven systems, knowledge repositories, analytics platforms, and other AWS services. Standardized agent-tool interfaces like the Model Context Protocol (MCP) are also beginning to influence how artificial intelligence systems integrate with outside capabilities. Recent industry discussions describe MCP as an emerging integration layer for agents that need consistent access to APIs, infrastructure, and business tools.
This points toward an architecture in which the foundation model acts as an intelligent coordinator while governed tools provide access to real-world systems.
Conclusion
An AI agent architecture with DynamoDB and Amazon Bedrock combines managed foundation models with scalable application data and controlled tool execution.
Bedrock provides the intelligence layer, the agent determines which capabilities are required, Lambda can execute those capabilities, and DynamoDB can provide both operational information and, where appropriate, semantic search through vector indexing. AWS's current reference architecture demonstrates how these components can be unified without necessarily introducing a separate vector database.
For organizations already building applications on AWS, this architecture can provide a practical foundation for customer-service agents, ecommerce assistants, enterprise search, knowledge applications, recommendation systems, and other AI-powered workflows.