Multiuser AI Chatbot Using Amazon Bedrock AgentCore

keywords session history, cross-session memory, document storage, RAG, prompt caching, authentication, and autoscaling acceptance criteria you provide .docx file with step by step instructions with screen copy for each step and end to end step by step video how to do . I can do it on my aws account from my windows computer . FOR LLM USE MAIN PROVIDERS OPENAI OR GEMINI I DO NOT PROVIDE LLM API KEAS AND AWS ACCOUINT FOR DEVELOPMENT YOU DO ALL ON YOUR OWN AWS ACCOUNT Educational Project: Industrial-Grade Multiuser AI Chatbot Using Amazon Bedrock AgentCore, AgentCore Harness, Persistent Memory, Document Conversations, Secure Code Execution, and AWS-Native Cybersecurity Project Overview We are seeking an experienced Senior AWS Generative AI Engineer, Agentic AI Engineer, or AWS Solutions Architect to design, implement, deploy, test, and document an industrial-grade, multiuser AI chatbot using Amazon Bedrock AgentCore and AgentCore Harness. The application must include: * A professional multiuser frontend * A secure and scalable backend * Amazon Bedrock foundation-model integration * Amazon Bedrock AgentCore Runtime * AgentCore Harness * AgentCore Memory * Short-term, resumable, and cross-session memory * User authentication using JWT tokens * Role-based access for users and administrators * Text responses, Python-generated plots, and Mermaid diagrams * Secure document upload and document-based conversations * Both RAG and non-RAG document-processing modes * Amazon S3 Vectors as the preferred low-cost vector-store option for RAG * Prompt caching for suitable non-RAG document conversations * Automatic scaling for changing user demand * CloudFront, AWS WAF, bot protection, rate limiting, monitoring, and security controls * Complete Infrastructure as Code * Complete educational documentation and a recorded walkthrough This must not be a simple chatbot demonstration. The selected engineer must approach the work as a senior engineer creating an end-to-end, production-oriented reference implementation that can later be adapted and hardened for a real business application. Important Scope Clarification The requirements below describe the intended system but may not include every component required for an industrial-strength implementation. Because this is also a learning project, the selected engineer is expected to: * Identify missing functional and nonfunctional requirements * Recommend additional AWS services and engineering controls where necessary * Explain which requirements are essential, optional, or recommended for future production use * Identify security, privacy, reliability, scalability, observability, performance, and cost risks * Implement all components reasonably required for a complete working system * Document assumptions, limitations, exclusions, risks, and future improvements * Explain what should not be done and why * Challenge unsafe, incomplete, unnecessarily expensive, or technically incorrect requirements The engineer should not implement only the literal words in this description if important components are missing. Professional architectural judgment is part of the required work. Primary Project Objectives * Build a working multiuser conversational AI application using Amazon Bedrock AgentCore * Use AgentCore Harness as the primary agent-development framework * Integrate an appropriate Amazon Bedrock foundation model * Maintain isolated memory for each authenticated user * Support multiple independent chat sessions per user * Allow users to close and later continue an earlier conversation from where they stopped * Remember selected facts and preferences across separate sessions * Implement configurable memory-retention and forgetting policies * Support secure PDF, DOC, DOCX, and TXT file uploads * Allow users to select RAG or non-RAG processing for uploaded files * Use Amazon S3 Vectors as the preferred low-cost RAG vector store * Use model prompt caching for eligible, frequently reused non-RAG document context * Generate text, Python plots, and Mermaid diagrams * Generate Mermaid diagrams as PNG files on the backend using Mermaid CLI * Secure the application with JWT authentication, authorization, CloudFront, AWS WAF, bot controls, and rate limiting * Scale automatically as concurrent usage increases and scale down during low usage * Provide user and administrator frontend interfaces * Deliver a reproducible, fully documented AWS deployment Amazon Bedrock AgentCore and AgentCore Harness Requirements Amazon Bedrock AgentCore must be a central part of the implemented architecture rather than being mentioned only as a project label. The application must use AgentCore Harness and appropriate AgentCore services, potentially including: * AgentCore Harness * AgentCore Runtime * AgentCore Memory * AgentCore Identity * AgentCore Gateway * AgentCore Code Interpreter * AgentCore Observability The engineer must: * Build the agent using AgentCore Harness * Explain the AgentCore Harness project structure and execution lifecycle * Explain how Harness connects to Runtime, Memory, Identity, Gateway, tools, and observability * Deploy the agent to AgentCore Runtime * Demonstrate both local development and AWS deployment * Explain which AgentCore capabilities are used and why * Clearly identify any AgentCore capabilities that are not used and explain why * Avoid creating unnecessary custom replacements for suitable managed AgentCore capabilities * Document relevant AWS regions, quotas, timeouts, concurrency limits, service maturity, and costs * Pin and document applicable SDK, CLI, Harness, and dependency versions Multiuser Architecture The application must support multiple independent users. Each user must have: * An individual authenticated account * An immutable internal user identifier * Isolated conversations * Isolated uploaded files * Isolated RAG indexes or secure document-level access controls * Isolated short-term and long-term memory * Individual usage and storage quotas * The ability to create multiple chat sessions * The ability to list, rename, open, continue, archive, and delete their sessions The implementation must prevent: * One user from seeing another user’s conversations * One user from retrieving another user’s memory * One user from accessing another user’s uploaded documents * One user from retrieving another user’s RAG chunks * Users from modifying another user’s session identifiers in API requests * Administrators from receiving unrestricted access through undocumented backdoors Authorization must be enforced by the backend. Hiding controls in the frontend is not sufficient. Three Required Memory Levels The implementation must clearly separate three different kinds of memory. Active-Session Context This is the context required during the currently active conversation. For example: * The user asks a question * The agent answers * The user asks a follow-up question using words such as it, that, or the previous result * The agent understands the reference using recent conversation context Resumable Session History The user must be able to close a conversation and later reopen the same session from the point where it stopped. For example: * The user creates Session A * The user has a long conversation in Session A * The user closes the application * The user returns later and selects Session A * The previous conversation is displayed * The user continues the conversation with the required context restored Cross-Session Long-Term Memory Important user facts, preferences, decisions, and summaries must be available across separate sessions when permitted by the configured memory policy. Required example: * In Session 1, the user says: My name is Peter * The user closes Session 1 * The user creates Session 2 * The user asks: What is my name * The agent answers: Your name is Peter This must be implemented using a stable authenticated user identity mapped to the appropriate AgentCore Memory actor identifier. It must not depend only on browser local storage or reuse of the same session identifier. Memory Safety and Isolation The engineer must test and prove that: * Peter’s memory cannot be returned to Mary * Memories are stored under the correct authenticated user identity * A forged user or session identifier cannot retrieve another user’s memory * Session summaries do not become another user’s context * Deleted or expired memories are no longer retrieved * Sensitive information is not automatically converted into long-term memory without an explicit policy Configurable Memory and Forgetting Policies The application must provide configurable memory-governance settings. Required settings include: * Maximum number of days to retain inactive session history * Maximum number of days to retain long-term memories * Maximum conversation tokens or equivalent context budget used for an active request * Maximum recent-message tokens retained verbatim * Maximum summary size * Maximum number of retrieved long-term memories per request * Maximum total memory tokens injected into a model request * Maximum number of stored sessions per user * Maximum total memory or storage allocation per user * Automatic summarization threshold * Automatic deletion or archival policy * User-requested forgetting * Administrator-configured global limits If AgentCore Memory does not natively enforce a required token-based or retention control, the engineer must implement and document an application-level control. The implementation should use a practical memory hierarchy: * Keep the most recent messages verbatim * Summarize older conversation sections * Retrieve only relevant long-term memories * Apply a strict context budget before invoking the model * Prevent unlimited conversation history from being sent to the model * Avoid storing every conversational statement as permanent memory Users must be able to: * View important stored memories where practical * Delete an individual memory * Clear one session * Clear all chat history * Request that selected information be forgotten * Delete uploaded files and associated indexes * Understand that deleting visible chat history and deleting extracted long-term memories may be separate operations Authentication, JWT, and Authorization The application must use secure JWT-based authentication. Amazon Cognito is the preferred AWS-native identity provider unless the engineer justifies another solution. The implementation must include: * User registration or administrator-created accounts * User sign-in and sign-out * Secure password policies * Email verification where appropriate * Password reset * Short-lived access tokens * Refresh-token handling * JWT signature verification * Issuer validation * Audience or client validation * Expiration validation * Token-use validation * Protection against accepting unsigned tokens * Protection against algorithm-substitution attacks * Backend authorization for every protected operation * Role-based access control for users and administrators * Token revocation and disabled-user behavior * Secure handling of tokens in the browser * Appropriate cookie protections if cookies are used * CSRF protection where applicable * Strict CORS configuration The system must not merely decode a JWT and trust its contents. It must validate the token cryptographically and verify all security-relevant claims. Administrative Interface A separate protected administrative interface must be provided. The administrator interface should include: * User-account status * User-role management * Active and archived session counts * Document-storage usage * RAG-index usage * Model invocation volume * Token usage and estimated cost * Requests, errors, and latency * Rate-limit events * WAF blocked-request statistics * Security alerts * Failed file-processing jobs * Memory usage and retention status * Ability to disable a compromised account * Ability to configure practical quotas and retention limits * Ability to inspect system health without automatically exposing private conversation content Administrative actions must be audited. The administrator should not receive unrestricted access to users’ conversations and uploaded documents by default. Any exceptional support-access mechanism must be explicit, authorized, logged, time-limited, and documented. Chat Session Management The user frontend must provide: * Create a new session * List earlier sessions * Search session titles where practical * Open an earlier session * Continue an earlier conversation * Rename a session * Archive a session * Delete a session * Export a conversation where appropriate * Display the last activity time * Clearly indicate which documents are attached to each conversation * Clearly distinguish session history from cross-session memory Chat titles should be generated automatically but remain editable by the user. Multimodal Response Interface The frontend must display more than text. Supported output types must include: * Normal text and Markdown * Tables * Syntax-highlighted code * Mermaid diagrams * Mermaid diagram PNG images produced by the backend * Python-generated plots * Downloadable generated artifacts * Structured error messages The backend must return a defined structured response format that identifies each content type. Mermaid Diagram Generation When a user requests a diagram, the agent must generate Mermaid source code. The backend must then: * Extract Mermaid code safely * Validate the diagram type and content * Apply size and complexity limits * Render the diagram using Mermaid CLI in an isolated backend environment * Generate a PNG file * Store or stream the PNG securely * Return the PNG and Mermaid source to the correct authenticated user * Display the PNG in the frontend * Allow the user to view and copy the Mermaid source * Allow the user to download the PNG * Handle Mermaid syntax errors without failing the entire conversation * Prevent Mermaid content from executing unsafe scripts or accessing external resources The application may also provide client-side Mermaid preview, but backend Mermaid CLI PNG generation is mandatory. Python Plot Generation The agent must be able to generate plots when requested or when a visual representation materially improves the answer. Examples include: * Line charts * Bar charts * Scatter plots * Histograms * Pie charts where appropriate * Time-series plots The implementation must: * Execute Python in a strongly isolated environment * Prefer AgentCore Code Interpreter where suitable * Restrict execution time, memory, CPU, output size, and permitted operations * Prevent access to AWS credentials and unrelated network or filesystem resources * Generate a PNG or another approved image format * Associate generated files with the authenticated user and session * Display the plot in the frontend * Allow secure download * Automatically expire temporary artifacts according to policy * Log execution metadata without unnecessarily storing sensitive code or data Arbitrary model-generated Python must not run directly inside the main backend process. Document Upload Requirements Authenticated users must be able to upload: * PDF files * DOC files * DOCX files * TXT files The engineer must define and implement: * Maximum file size * Maximum page count * Maximum files per session * Maximum total storage per user * Supported character encodings * Password-protected file behavior * Scanned-PDF and OCR behavior * Corrupted-file behavior * Duplicate-file behavior * Retention and deletion policies * Upload status and processing status * Clear user-facing failure messages Secure Upload Pipeline The file-upload pipeline must include: * Authenticated uploads * Short-lived presigned URLs where appropriate * Server-side verification of user ownership * File extension validation * MIME-type validation * File-signature validation * Size limits * Malware scanning or a clearly documented AWS-native scanning architecture * Quarantine before processing * Encryption at rest * S3 Block Public Access * Per-user object prefixes or another secure isolation mechanism * Lifecycle expiration rules * Audit logging * Prevention of path and object-key manipulation * Protection against malicious PDFs, document bombs, decompression bombs, and parser attacks A file must not become available to the model, RAG pipeline, or another user until required validation and security processing have completed. Two Document Conversation Modes The application must support both RAG and non-RAG document processing. The user should be able to select the mode for each file or collection. RAG Mode RAG should be used for large documents, multiple documents, persistent knowledge collections, and cases where only relevant passages should be sent to the model. The preferred design is: * Original documents stored securely in Amazon S3 * Amazon Bedrock Knowledge Bases or another justified AWS-native ingestion pipeline * Amazon S3 Vectors as the preferred low-cost vector store * Appropriate parsing, chunking, metadata, embeddings, retrieval, and citations The RAG implementation must include: * User and tenant isolation * Document-level metadata * Configurable chunking strategy * Embedding-model selection and justification * Retrieval configuration * Optional reranking where justified * Source citations in agent responses * Ingestion status * Re-indexing after file updates * Removal of vectors after file deletion * Tests for cross-user retrieval leakage * Evaluation of retrieval relevance and groundedness * Protection against prompt injection contained inside uploaded documents Non-RAG Direct-Context Mode Non-RAG mode should be available for smaller files that can be safely and economically included in the model context. The system must: * Extract and normalize supported document content * Validate whether the content fits within the selected model’s context limits * Apply an explicit token budget * Refuse, truncate, summarize, or recommend RAG when a document is too large * Clearly inform the user which behavior occurred * Reuse eligible document context through Amazon Bedrock prompt caching when supported by the selected model * Explain cache thresholds, lifetime, cache-hit behavior, and limitations * Avoid claiming that prompt caching is permanent storage * Avoid sending an unchanged large document repeatedly when caching is available and economical * Fall back safely when prompt caching is unavailable or the content is not eligible Mixed Document Mode A single conversation must support a practical mixture of document-processing strategies. For example: * A large technical manual uses RAG with S3 Vectors * A small contract uses non-RAG direct context * Frequently reused stable instructions use prompt caching * The user asks one question that requires information from all selected sources The system must label each document’s processing mode and prevent the same document from being accidentally charged or processed through multiple unnecessary pipelines. Frontend Requirements The user frontend must provide: * Professional responsive design * Registration and sign-in experience * Multi-session chat navigation * Session creation and continuation * Text and Markdown responses * Tables and code formatting * Mermaid PNG display * Mermaid source viewing and copying * Python plot display * Artifact download controls * Secure drag-and-drop document upload * Upload and processing progress * RAG or non-RAG mode selection * Document attachment and removal * Source citations for RAG answers * Memory-management controls * Clear loading, retry, cancellation, and error states * Streaming responses where appropriate * Basic accessibility and keyboard usability The frontend must not expose AWS credentials, backend secrets, internal prompts, stack traces, or private object locations. Scalable Backend and Autoscaling The complete application must scale up when many users use it and scale down during periods of low activity. The engineer must recommend and justify the deployment architecture, such as: * AgentCore Runtime for the agent * Serverless API services * AWS Lambda where appropriate * Amazon API Gateway where appropriate * Amazon ECS with Fargate where long-running services or specialized containers are required * Application Load Balancer where appropriate * Amazon SQS for asynchronous ingestion and rendering jobs * DynamoDB or another justified managed database for application metadata and session indexes * S3 for uploaded and generated files The design must address: * Concurrent users * Streaming connections * Long-running model responses * Document-ingestion jobs * Mermaid rendering jobs * Python plot jobs * Backpressure * Queue depth * Retry and dead-letter queues * Idempotency * Duplicate requests * Connection and model timeouts * Scale-up behavior * Scale-down behavior * Minimum and maximum capacity * Cold starts * Cost protection * Model quotas and throttling * Graceful degradation during overload Autoscaling must not be demonstrated only by selecting an AWS service that theoretically scales. The engineer must define scaling signals, thresholds, capacity limits, quotas, tests, and expected behavior. CloudFront, AWS WAF, Bot, and Attack Protection The public application must use Amazon CloudFront and AWS WAF where technically appropriate. AWS WAF protection should include: * AWS-managed rule groups * Core common protection * Known bad-input protection * IP reputation lists * Anonymous IP protection where justified * SQL injection protection * Cross-site scripting protection * Rate-based rules * Login-endpoint protection * Upload-endpoint protection * API-endpoint protection * Geographic restrictions if required * Bot visibility and bot-control capabilities where justified * Count-mode evaluation before selected rules are changed to blocking * WAF logging and sampled-request analysis The goal is to detect, throttle, challenge, and block malicious automation and known attack patterns while minimizing harm to legitimate users. No system can guarantee that every hacker or bot will be permanently banned. The engineer must design practical layered protection including: * Per-IP rate limits * Per-user rate limits * Per-session rate limits * Per-endpoint limits * Model-token and cost quotas * Upload quotas * Authentication failure limits * Temporary blocking * CAPTCHA or challenge flows where appropriate * Compromised-account disabling * Abuse detection * Security alerts * Manual and automatic response procedures * Allow and deny lists with expiration and audit history The engineer must explain false positives, NAT and shared-IP risks, IPv6 considerations, proxy-header trust, distributed bot attacks, account farming, credential stuffing, and cost-exhaustion attacks. Additional Cybersecurity Requirements The project must include a documented threat model covering at least: * Prompt injection * Indirect prompt injection inside uploaded documents * Cross-user data leakage * Memory poisoning * RAG poisoning * Malicious file uploads * Insecure direct object references * JWT theft or forgery * Privilege escalation * Administrator-account compromise * Cross-site scripting * Cross-site request forgery * SQL or NoSQL injection where applicable * Server-side request forgery * Dependency and container vulnerabilities * Data exfiltration through agent tools * Arbitrary code execution * Denial of service * Model-cost exhaustion * Logging of confidential information * Public S3 exposure * Overly broad IAM permissions * Supply-chain attacks * Secrets committed to source control * Mermaid-rendering attacks * Python-code-execution attacks The implementation must use: * Least-privilege IAM * Encryption in transit * Encryption at rest * AWS Secrets Manager or Systems Manager Parameter Store where appropriate * S3 Block Public Access * Secure headers * Dependency and container scanning * Audit logging * Secure deletion and lifecycle controls * Environment separation * No hard-coded credentials * No secrets exposed to generated code * No unrestricted agent tool permissions * No trust in model output without validation Observability and Administration The solution must provide operational visibility for: * Frontend availability * API availability * AgentCore invocations * Model invocations * Active users * Concurrent sessions * Request volume * Response latency * Token consumption * Prompt-cache usage where available * RAG retrieval latency * RAG retrieval quality evaluation * S3 Vector usage * Document-ingestion failures * Mermaid-rendering failures * Python-execution failures * Authentication failures * Authorization failures * WAF blocks and challenges * Rate-limit events * Queue depth * Dead-letter queue messages * Application errors * Estimated AWS cost * Per-user usage and quotas where appropriate Requests should use correlation identifiers so an operator can trace a request across CloudFront, WAF, API, backend, AgentCore, model invocation, document retrieval, and artifact generation. Industrial-Grade Reliability Requirements The system must include: * Structured error handling * Defined timeout policies * Controlled retries with backoff and jitter * Idempotency for operations that may be repeated * Circuit-breaking or graceful degradation where appropriate * Asynchronous processing for long-running tasks * Dead-letter queues * Health checks * Backup and recovery strategy * Data-retention strategy * Deployment rollback procedure * Safe database and schema migration procedure * Disaster-recovery assumptions * Regional-failure limitations * Service-quota analysis * Load testing * Security testing * Cost-limit controls * Operational runbooks Required Testing The engineer must create and execute tests for: * User registration, login, logout, and token refresh * Expired, malformed, forged, and revoked JWTs * User and administrator authorization * Multiple simultaneous users * Cross-user conversation isolation * Cross-user document isolation * Cross-user RAG isolation * Active-session context * Resuming an earlier session * Cross-session long-term memory * The Peter-name memory example * Memory expiration by days * Memory reduction by token budget * User-requested forgetting * Session deletion * PDF, DOC, DOCX, and TXT uploads * Malicious and malformed files * RAG document conversations * Non-RAG direct-context conversations * Prompt-cache use and cache misses * Mixed RAG and non-RAG conversations * Mermaid source generation * Backend Mermaid CLI PNG rendering * Invalid and malicious Mermaid input * Python plot generation * Python sandbox escape attempts * Excessive request rates * Bot and credential-stuffing simulations * WAF count, challenge, and block behavior * Autoscaling under increasing load * Scale-down after traffic decreases * Model throttling * Backend timeouts * Queue retries and dead-letter behavior * Clean deployment using Infrastructure as Code * Complete resource removal Required Deliverables * Complete frontend source code * Complete user interface * Complete administrator interface * Complete backend source code * AgentCore Harness project * AgentCore Runtime deployment * AgentCore Memory implementation * AgentCore Identity or justified authentication integration * AgentCore Gateway integration where applicable * Secure Python plot-generation capability * Backend Mermaid CLI PNG-generation service * Multi-session conversation management * Cross-session memory implementation * Configurable memory and forgetting policies * Secure document-upload pipeline * RAG implementation using S3 Vectors * Non-RAG direct-context implementation * Prompt-caching implementation for eligible models and documents * JWT authentication and role-based authorization * CloudFront configuration * AWS WAF configuration * Bot and rate-limit protection * Autoscaling configuration * Infrastructure as Code * CI and CD pipeline * Automated test suite * Load-test scripts and results * Security-test plan and results * Threat model * Architecture diagrams * Data-flow diagrams * Authentication sequence diagram * Memory lifecycle diagram * Document-processing diagram * Deployment guide * Configuration guide * User guide * Administrator guide * Troubleshooting guide * Operational runbooks * Backup and recovery guide * Cost estimate * Cost-control recommendations * Cleanup instructions * Recorded implementation and deployment walkthrough * Final knowledge-transfer session Educational Documentation Requirements For every major feature, the documentation must explain: * WHAT is being implemented * WHY it is required * HOW it works internally * HOW it interacts with other components * HOW to configure it * HOW to deploy it * HOW to test it * HOW to monitor it * WHAT can fail * HOW to troubleshoot it * WHAT NOT TO DO * WHAT is still required before handling sensitive production data The documentation must be understandable to a college student or junior engineer while remaining technically useful to experienced engineers. Recorded Walkthrough The recorded walkthrough must demonstrate: * Complete architecture * AgentCore Harness project structure * Local agent execution * AgentCore Runtime deployment * Multiuser registration and authentication * User and administrator interfaces * Multiple sessions for one user * Closing and resuming an earlier session * The Peter cross-session memory example * Memory deletion and expiration controls * PDF, DOCX, and TXT uploads * RAG processing with S3 Vectors * Non-RAG direct-context processing * Prompt-cache behavior * Mixed document-processing modes * Mermaid generation and backend PNG rendering * Python plot generation * CloudFront and WAF configuration * Rate-limit and bot-protection tests * Autoscaling under load * Logs, metrics, dashboards, and alarms * Common failure scenarios * Complete cleanup and removal of chargeable resources Acceptance Criteria The project will be accepted when: * The application is successfully deployed in AWS * AgentCore Harness and AgentCore Runtime are genuinely used * Multiple authenticated users can use the application simultaneously * Each user’s chats, documents, RAG results, and memories remain isolated * Users can create and manage multiple sessions * Users can continue earlier sessions from where they stopped * Cross-session memory passes the Peter-name test * Memory day limits and token budgets are implemented and demonstrated * JWT authentication and backend authorization are validated * User and administrator interfaces operate correctly * PDF, DOC, DOCX, and TXT uploads work securely * RAG using Amazon S3 Vectors works with citations * Non-RAG document conversations work within defined context limits * Prompt caching is demonstrated where supported and eligible * Mermaid diagrams are generated as backend PNG files and displayed in the frontend * Python plots are generated in an isolated environment and displayed in the frontend * CloudFront, AWS WAF, bot controls, and rate limits are implemented and tested * The application scales up under load and scales down after load decreases * Logging, monitoring, alerts, and cost controls are operational * Infrastructure as Code can reproduce the environment * Automated, security, isolation, and load tests pass * Documentation and the recorded walkthrough are complete * Cleanup instructions successfully remove chargeable resources Expected Freelancer Qualifications * Strong Amazon Bedrock experience * Practical Amazon Bedrock AgentCore experience * AgentCore Harness experience * AgentCore Memory and multiuser memory-isolation experience * AWS authentication and Amazon Cognito experience * JWT security expertise * RAG and vector-search experience * Amazon Bedrock Knowledge Bases experience * Amazon S3 Vectors experience * Secure document-processing experience * AWS WAF and CloudFront experience * Secure code-execution or sandboxing experience * Serverless or container autoscaling experience * Infrastructure as Code experience * CI and CD experience * Observability, security testing, and load-testing experience * Ability to produce detailed educational documentation Proposal Requirements Please include: * Relevant Bedrock, AgentCore, and AgentCore Harness projects * Experience implementing multiuser and cross-session agent memory * Your proposed architecture * Your proposed frontend and backend technologies * Your approach to session history and cross-session memory * How you will implement memory retention by days and context limits by tokens * How you will prevent memory leakage between users * Your Cognito and JWT security design * Your document-upload security design * Your RAG design using S3 Vectors * Your non-RAG direct-context and prompt-caching design * Your approach to Mermaid CLI rendering * Your approach to isolated Python plot generation * Your autoscaling design and scaling metrics * Your CloudFront, WAF, bot-protection, and abuse-prevention design * Your proposed Infrastructure as Code technology * Your testing and load-testing approach * Estimated AWS operating cost for low, medium, and high usage * Project timeline and milestones * Fixed-price or milestone-based cost * Important missing requirements you recommend adding * Known AWS service limitations or risks The final result must function as both a working AWS application and a detailed production-oriented implementation playbook. Technical Accuracy Note Amazon AgentCore distinguishes sessions from user-level actors, allowing properly isolated long-term memory across sessions. AgentCore Harness integrates with Runtime, Memory, Gateway, Code Interpreter, and Observability. Amazon S3 Vectors is now generally available and integrates with Bedrock Knowledge Bases as a cost-effective vector store. Prompt caching should be treated as a temporary inference optimization, not permanent document storage or a replacement for RAG. These distinctions must be reflected in the implemented architecture. [AgentCore Memory](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/memory-organization.html), [AgentCore Harness](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/what-is-bedrock-agentcore.html), [S3 Vectors](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-vectors-bedrock-kb.html)