PromptBase
PromptBase SelectGet Select
Close icon
General
Home
Marketplace
Create
Hire
Login
Chat
Sell
Explore

Prompt Details

Model
(claude-5-5-sonnet)
Token size
5,002
Example input
[Describe the AI agent product, its purpose, and core functionality]: AI customer support agent that answers customer questions, tracks orders, handles returns, and processes refund requests. [Single Agent / Multi-Agent / Agentic RAG / AI Automation Platform / Enterprise AI Agent / Other]: Multi-Agent AI System. [Prototype / MVP / Small Production / High-Traffic Production / Enterprise]: Small Production, initially 5,000 users and scalable to 100,000 users. [Python / FastAPI / Node.js / TypeScript / PostgreSQL / Redis / Vector Database / Cloud Provider / No Preference]: Python, FastAPI, PostgreSQL, Redis, Celery, React, OpenAI API, Docker. [Expected users, workload, integrations, security requirements, deployment environment, budget constraints, and special requirements]: Customer authentication. Order tracking integration. Product information retrieval. Return and refund workflows. Human support escalation. Multi-tenant architecture. Secure payment-related data handling. 24/7 availability. Budget-conscious cloud deployment.
Example output
### PHASE 1: REQUIREMENTS ANALYSIS & SYSTEM DEFINITION ### 1.1 Project Overview The proposed system is a multi-agent AI customer support platform designed for e-commerce businesses. Customers interact with an AI-powered support interface. The backend identifies customer intent and delegates tasks to specialized agents. The system supports: * Product-related questions. * Order status tracking. * Return eligibility verification. * Refund request initiation. * Customer complaint handling. * Human support escalation. Primary business objective: Reduce repetitive customer support workload while providing faster, consistent customer assistance. ### 1.2 User Roles | User role | Responsibilities | | -------------- | -------------------------------------------- | | Customer | Ask questions, track orders, request returns | | Support agent | Review escalated conversations | | Business admin | Configure agents and policies | | Platform admin | Manage tenants and infrastructure | | System worker | Execute asynchronous tasks | ### 1.3 Functional Requirements | ID | Requirement | Priority | | ----- | ----------------------------- | -------- | | FR-01 | Customer authentication | Critical | | FR-02 | AI conversation management | Critical | | FR-03 | Product information retrieval | High | | FR-04 | Order tracking | Critical | | FR-05 | Return eligibility checking | Critical | | FR-06 | Refund workflow | Critical | | FR-07 | Human escalation | High | | FR-08 | Usage tracking | Medium | | FR-09 | Tenant management | High | | FR-10 | Audit logging | High | ### 1.4 Non-Functional Requirements * Availability: Target 99.9%, subject to infrastructure and dependency design. * Security: Encrypted communication and protected customer information. * Scalability: Horizontal API and worker scaling. * Performance: Target p95 API latency below 500 ms for non-LLM endpoints. * Reliability: Retry policies and execution recovery. * Maintainability: Modular backend architecture. * Cost efficiency: Managed infrastructure with minimal operational overhead. LLM response latency is excluded from the 500 ms target because external model inference can take considerably longer. ### 1.5 Confirmed Requirements vs Assumptions Confirmed from input: * Multi-agent application. * FastAPI and PostgreSQL. * Redis and Celery. * React frontend. * OpenAI integration. * Multi-tenancy. Assumptions: * E-commerce stores connect through REST APIs. * Refunds require business-policy verification. * High-value refunds require human approval. * Payment card information is never stored by the AI platform. * Each business has isolated customer and order records. ### 1.6 System Requirements Specification Phase 1 Complete The backend must provide a secure, multi-tenant AI support platform with persistent conversations, agent orchestration, external commerce integrations, asynchronous execution, controlled refund workflows, and operational monitoring. ### PHASE 2: BACKEND SYSTEM ARCHITECTURE DESIGN ### 2.1 Architecture Selection Selected: Modular Monolith + Asynchronous Workers Why? The application requires multiple logical services, but starting with independently deployed microservices would increase infrastructure and maintenance costs. The recommended architecture: * Modular FastAPI backend. * Separate agent execution workers. * PostgreSQL as primary database. * Redis for caching and queue coordination. * Celery for background jobs. * Object storage for uploaded documents. * External LLM provider adapter. ### 2.2 System Architecture Diagram ![Using LLMs and VectorDBs as Cloud-Native Backing Services in Microservices Architecture | by Mehmet Ozkaya | Medium](https://images.openai.com/static-rsc-4/XFuZi_x1Ipxl1P0HGmmdRcew2g_HUuuTHYgboaVRO7dhdF85W3foTo469SUOiDe5p_71ovuSPHGEr0Hd0nSazmEmMTDh7Vx3WtCV6FYWuT74JfjWMivKwJ2CbE0300eje0TcrH7u5JnWen5VjCfEuIGFNRjoV3Kkab45wqcWKMLrjYcQ_PNnIU94gicXKovX?purpose=fullsize) ```mermaid flowchart TD A[React Customer Interface] --> B[FastAPI Backend] B --> C[Authentication and RBAC] B --> D[Conversation Manager] D --> E[Multi-Agent Orchestrator] E --> F[Product Agent] E --> G[Order Agent] E --> H[Returns Agent] E --> I[Escalation Agent] F --> J[LLM Adapter] G --> K[E-commerce API] H --> K I --> L[Human Support Dashboard] B --> M[(PostgreSQL)] B --> N[(Redis)] E --> O[Celery Workers] O --> M O --> P[External Integrations] ``` ### 2.3 Component Responsibilities | Component | Responsibility | Communication | | ------------------ | ---------------------- | -------------- | | FastAPI | HTTP API processing | REST | | Auth module | Authentication | Internal calls | | Agent orchestrator | Agent routing | Internal calls | | LLM adapter | Model communication | HTTPS | | PostgreSQL | Persistent data | SQL | | Redis | Cache and coordination | Redis protocol | | Celery | Background processing | Queue | | Commerce adapter | Order and product APIs | REST | | Monitoring | Logs and metrics | Telemetry | ### 2.4 Architecture Alternatives | Architecture | Decision | | ---------------- | ----------------------------- | | Modular monolith | Selected | | Microservices | Future scaling option | | Serverless | Not initially necessary | | Event-driven | Used for background workflows | | Full Kubernetes | Not justified for initial MVP | Trade-off: A modular monolith is simpler to deploy, but requires strict module boundaries to prevent tight coupling. ### PHASE 3: SYSTEM COMPONENT & SERVICE BOUNDARY DESIGN ### 3.1 Logical Backend Modules | Module | Main responsibility | Data ownership | | ---------------- | ----------------------- | -------------------- | | Identity | Login and access | Users | | Tenant | Business accounts | Organizations | | Agent Management | Agent configuration | Agents | | Conversation | Messages and sessions | Conversations | | Orchestration | Agent task coordination | Executions | | Integrations | Store connections | Integration metadata | | Memory | Customer context | Memory records | | Billing | Usage and subscriptions | Usage records | | Notification | Support alerts | Notification records | | Audit | Security event history | Audit logs | ### 3.2 Internal Module Structure ```text backend/ │ ├── app/ │ ├── api/ │ ├── core/ │ ├── auth/ │ ├── tenants/ │ ├── users/ │ ├── agents/ │ ├── orchestrator/ │ ├── conversations/ │ ├── executions/ │ ├── memory/ │ ├── integrations/ │ ├── billing/ │ ├── notifications/ │ ├── audit/ │ └── database/ │ ├── workers/ ├── tests/ ├── migrations/ ├── docker/ └── main.py ``` ### 3.3 Service Boundary Decisions Keep these modules together initially: * Authentication and user management. * Agent configuration and management. * Conversation and session management. * Billing and usage recording. Keep independently scalable: * Celery workers. * Agent execution workloads. * Monitoring infrastructure. External commerce systems remain independent integration dependencies. ### PHASE 4: AI AGENT RUNTIME BACKEND ARCHITECTURE ### 4.1 Multi-Agent Design ![Orquestación Multi-Agente con LangGraph: Guía Producción 2025 | BCloud Consulting](https://images.openai.com/static-rsc-4/c7GTnEcrnnwez4yTwnGO-L-mNwKa7tfSyeuYnSIZOFBHAzxgqyz7R1L5f-PEXKVWhtDMDDB6dgyrpdrtGC7ZYczbm4YPDXxxxcp8iWIRHXXSjxs4eBDsrhrbGGJH5de3R2ahTgr-rJZ6AcgWNizkoyczVD_cOtHz44RyLTZ2pYzP1NGqDIirOsxk8_OAuN1L?purpose=fullsize) The system uses a supervisor-style orchestrator. Agent 1: Product Information Agent * Searches product catalog. * Retrieves product specifications. * Answers product questions. Agent 2: Order Tracking Agent * Verifies customer ownership. * Retrieves order status. * Checks delivery information. Agent 3: Returns and Refund Agent * Checks return eligibility. * Validates refund policy. * Initiates permitted refund workflows. Agent 4: Escalation Agent * Detects unresolved complaints. * Creates support tickets. * Transfers conversations to human agents. ### 4.2 Agent Lifecycle ```mermaid stateDiagram-v2 [*] --> Created Created --> Queued Queued --> Running Running --> WaitingForTool WaitingForTool --> Running Running --> Completed Running --> Failed Running --> Cancelled Failed --> RetryPending RetryPending --> Queued Completed --> [*] Cancelled --> [*] ``` ### 4.3 Execution Workflow * Customer submits a message. * Backend validates identity and tenant. * Conversation manager retrieves context. * Orchestrator identifies customer intent. * Relevant specialized agent receives the task. * Agent calls an authorized tool if required. * Tool result is validated. * Agent produces a response. * Execution and message records are persisted. * Frontend receives the response. ### 4.4 Runtime Persistence Every execution should contain: * execution_id * tenant_id * conversation_id * agent_id * execution_status * input_payload * output_payload * started_at * completed_at * error_code * retry_count ### 4.5 Runtime Safety * Maximum execution time: configurable. * Maximum agent iterations: configurable. * Tool-specific permission policies. * Tenant-level concurrency limits. * Cancellation support. * Human approval for sensitive operations. * No unrestricted shell or database access. Important: A refund agent must not independently decide to transfer money. It must use validated business rules and an authorized payment-provider operation. ### PHASE 5: API DESIGN & CONTRACT ENGINEERING ### 5.1 API Endpoint Directory | Method | Endpoint | Purpose | | ------ | ------------------------------- | --------------------- | | POST | /api/v1/auth/login | User login | | POST | /api/v1/auth/refresh | Refresh token | | GET | /api/v1/users/me | Current user | | POST | /api/v1/agents | Create agent | | GET | /api/v1/agents | List agents | | POST | /api/v1/conversations | Create conversation | | POST | /api/v1/conversations//messages | Submit message | | POST | /api/v1/executions | Start execution | | GET | /api/v1/executions/ | Execution status | | POST | /api/v1/executions//cancel | Cancel execution | | POST | /api/v1/tickets | Create support ticket | | GET | /api/v1/usage | Usage information | ### 5.2 Example: Submit Customer Message Request ```json { "message": "Where is my order?", "conversation_id": "conv_1001", "metadata": { "channel": "web" } } ``` Response ```json { "execution_id": "exec_9001", "conversation_id": "conv_1001", "status": "queued", "message": "Your request is being processed." } ``` ### 5.3 Execution Status Response ```json { "execution_id": "exec_9001", "status": "completed", "agent": "order_tracking_agent", "result": { "order_status": "shipped", "estimated_delivery": "2026-11-15" } } ``` ### 5.4 Error Contract ```json { "error": { "code": "ORDER_NOT_FOUND", "message": "The requested order could not be found.", "request_id": "req_12345", "details": {} } } ``` ### 5.5 API Engineering Rules * Version APIs using `/api/v1`. * Use cursor pagination for large datasets. * Validate requests with Pydantic. * Use JWT or secure session authentication. * Apply tenant-level authorization. * Use idempotency keys for refund and other financial operations. * Document contracts using OpenAPI. * Return HTTP 202 for queued asynchronous execution. ### PHASE 6: DATABASE ARCHITECTURE & DATA MODELING ### 6.1 Database Selection | Technology | Purpose | | -------------- | -------------------------------------- | | PostgreSQL | Primary relational database | | Redis | Cache and queue coordination | | Object Storage | Documents and uploaded files | | pgvector | Optional semantic memory and retrieval | PostgreSQL is the authoritative data store. Redis must not be treated as the permanent source of execution or financial records. ### 6.2 Main Database Entities ```mermaid erDiagram TENANTS ||--o{ USERS : contains TENANTS ||--o{ AGENTS : owns TENANTS ||--o{ CONVERSATIONS : owns USERS ||--o{ CONVERSATIONS : creates CONVERSATIONS ||--o{ MESSAGES : contains CONVERSATIONS ||--o{ EXECUTIONS : triggers AGENTS ||--o{ EXECUTIONS : processes EXECUTIONS ||--o{ TOOL_LOGS : records TENANTS ||--o{ USAGE_RECORDS : tracks TENANTS ||--o{ AUDIT_LOGS : generates ``` ### 6.3 Representative SQL Schema ```sql CREATE TABLE tenants ( id UUID PRIMARY KEY, name VARCHAR(255) NOT NULL, status VARCHAR(30) NOT NULL, created_at TIMESTAMPTZ DEFAULT NOW() ); CREATE TABLE users ( id UUID PRIMARY KEY, tenant_id UUID NOT NULL REFERENCES tenants(id), email VARCHAR(255) NOT NULL, password_hash TEXT, role VARCHAR(50) NOT NULL, created_at TIMESTAMPTZ DEFAULT NOW(), UNIQUE (tenant_id, email) ); CREATE TABLE agents ( id UUID PRIMARY KEY, tenant_id UUID NOT NULL REFERENCES tenants(id), name VARCHAR(150) NOT NULL, agent_type VARCHAR(100) NOT NULL, configuration JSONB NOT NULL, is_active BOOLEAN DEFAULT TRUE, created_at TIMESTAMPTZ DEFAULT NOW() ); CREATE TABLE conversations ( id UUID PRIMARY KEY, tenant_id UUID NOT NULL REFERENCES tenants(id), user_id UUID NOT NULL REFERENCES users(id), status VARCHAR(30) NOT NULL, created_at TIMESTAMPTZ DEFAULT NOW() ); CREATE TABLE messages ( id UUID PRIMARY KEY, conversation_id UUID NOT NULL REFERENCES conversations(id), role VARCHAR(30) NOT NULL, content TEXT NOT NULL, created_at TIMESTAMPTZ DEFAULT NOW() ); CREATE TABLE executions ( id UUID PRIMARY KEY, tenant_id UUID NOT NULL REFERENCES tenants(id), conversation_id UUID NOT NULL REFERENCES conversations(id), agent_id UUID REFERENCES agents(id), status VARCHAR(30) NOT NULL, input_payload JSONB, output_payload JSONB, error_code VARCHAR(100), created_at TIMESTAMPTZ DEFAULT NOW(), completed_at TIMESTAMPTZ ); CREATE INDEX idx_conversations_tenant ON conversations(tenant_id); CREATE INDEX idx_executions_status ON executions(status); CREATE INDEX idx_messages_conversation ON messages(conversation_id); ``` Production implementation should also add tenant-aware foreign key constraints, suitable composite indexes, database migrations, retention policies, and row-level security where appropriate. ### PHASE 7: AGENT STATE, MEMORY & SESSION PERSISTENCE ### 7.1 Memory Architecture The system separates four different types of information. | Memory type | Storage | Purpose | | -------------------------- | ---------- | ----------------------------- | | Temporary execution state | Redis | Active task coordination | | Conversation history | PostgreSQL | Previous messages | | Structured customer memory | PostgreSQL | Customer preferences | | Semantic memory | pgvector | Relevant contextual retrieval | ### 7.2 Memory Retrieval Workflow ```mermaid flowchart TD A[New Customer Message] --> B[Load Conversation] B --> C[Retrieve Customer Context] C --> D[Semantic Retrieval if Needed] D --> E[Build Agent Context] E --> F[Execute Agent] F --> G[Persist Result] ``` ### 7.3 Recovery Strategy * Store execution checkpoints in PostgreSQL. * Use Redis for temporary coordination. * Restore incomplete executions from durable checkpoints. * Revalidate external order and refund status before resuming. * Apply idempotency keys to prevent duplicate operations. * Expire temporary sessions according to configured policies. Important: Never store sensitive payment credentials or unrestricted API secrets inside agent memory. ### PHASE 8: QUEUE, EVENT & BACKGROUND WORKER ARCHITECTURE ### 8.1 Queue Technology Selected: Celery + Redis This is appropriate for the initial workload because the application needs background processing without introducing Kafka-level operational complexity. ### 8.2 Queue Types | Queue | Workload | | ------------------ | -------------------------- | | agent_tasks | Agent execution | | order_tasks | Order status retrieval | | refund_tasks | Refund processing | | notification_tasks | Email and alerts | | maintenance_tasks | Cleanup and scheduled jobs | ### 8.3 Event Contracts Example: ```json { "event_id": "evt_001", "event_type": "agent.execution.requested", "tenant_id": "tenant_001", "execution_id": "exec_001", "timestamp": "2026-11-13T10:00:00Z", "payload": { "agent_type": "order_tracking" } } ``` ### 8.4 Reliability Controls * Bounded retries. * Exponential backoff. * Dead-letter handling. * Idempotent workers. * Task status persistence. * Worker heartbeat monitoring. * Scheduled task recovery. For critical database-to-queue events, use a transactional outbox pattern to avoid losing events between database commits and queue publication. ### PHASE 9: LLM PROVIDER & EXTERNAL TOOL INTEGRATION ### 9.1 LLM Adapter Architecture The backend should not directly couple every agent to a specific provider API. Create a common internal interface. ```python class LLMProvider: async def generate( self, messages, model, tools=None ): raise NotImplementedError ``` Provider adapters: * OpenAI adapter. * Alternative provider adapter. * Future model provider adapters. ### 9.2 Tool Integration | Tool | Responsibility | | ----------------------- | ---------------------- | | get_order_status | Retrieve order | | search_products | Search catalog | | check_return_policy | Validate return | | create_return_request | Initiate return | | request_refund_approval | Request human approval | | create_support_ticket | Escalation | ### 9.3 Provider Failure Handling * Request timeout. * Rate-limit handling. * Provider-specific error normalization. * Circuit breaker. * Controlled fallback. * Token usage recording. Fallback models must be checked for tool-calling and structured-output compatibility before being selected. ### 9.4 Integration Security * Credentials stored in secret manager. * Allowlisted external API domains. * Request and response validation. * Tenant-specific integration permissions. * Tool-level authorization. * Sensitive data redaction. ### PHASE 10: AUTHENTICATION, AUTHORIZATION & SECURITY ### 10.1 Authentication Architecture Recommended: * OAuth 2.0 / OpenID Connect for enterprise identity integrations. * Short-lived access tokens. * Refresh token rotation. * Password hashing using Argon2id where passwords are managed locally. * MFA for administrative accounts. ### 10.2 Role-Based Access Control | Role | Permissions | | -------------- | ---------------------------- | | Customer | Own conversations and orders | | Support Agent | Assigned support cases | | Business Admin | Tenant settings | | Platform Admin | Platform management | ### 10.3 AI Agent Threat Model | Threat | Mitigation | | ------------------------- | ------------------------------------ | | Prompt injection | Treat retrieved content as untrusted | | Unauthorized refunds | Explicit permission and approval | | Data leakage | Tenant-level authorization | | API abuse | Rate limiting | | Credential theft | Secret manager | | SQL injection | Parameterized queries | | Tool misuse | Tool allowlists and validation | | Excessive agent execution | Budgets and iteration limits | ### 10.4 Security Architecture ```mermaid flowchart TD A[Customer] --> B[HTTPS] B --> C[Authentication] C --> D[Authorization] D --> E[Tenant Validation] E --> F[API Backend] F --> G[Agent Permission Layer] G --> H[Approved Tools] H --> I[External Services] F --> J[Audit Logging] ``` High-impact operations require explicit policy checks and, where configured, human approval. ### PHASE 11: MULTI-TENANT BACKEND ARCHITECTURE ### 11.1 Tenant Isolation Model Selected: Shared PostgreSQL + tenant_id Each business receives a unique tenant identifier. Every tenant-owned record must be scoped to that tenant. ### 11.2 Isolation Strategy * Tenant identified from authenticated identity. * Never trust tenant_id supplied directly by an untrusted client. * Apply tenant-scoped database queries. * Use PostgreSQL row-level security as defense in depth. * Separate tenant integration credentials. * Apply tenant-specific rate and usage limits. * Keep audit logs tenant-aware. ### 11.3 Cross-Tenant Protection Example: ```sql SELECT * FROM conversations WHERE id = :conversation_id AND tenant_id = :authenticated_tenant_id; ``` A customer from Tenant A must never access Tenant B's conversations, agents, files, or execution results. For enterprise customers requiring stronger isolation, dedicated databases can be introduced. ### PHASE 12: SCALABILITY & PERFORMANCE ENGINEERING ### 12.1 Scaling Strategy | Component | Scaling method | | -------------- | -------------------------------------- | | FastAPI | Horizontal replicas | | Celery workers | Queue-based scaling | | PostgreSQL | Indexing and connection pooling | | Redis | Memory sizing and appropriate topology | | LLM layer | Concurrency and token budgets | | Object storage | Managed storage scaling | ### 12.2 Potential Bottlenecks | Bottleneck | Root cause | Recommended solution | | -------------------------- | ---------------------- | ------------------------------ | | Slow API | Blocking operations | Async I/O | | Slow queries | Missing indexes | Query optimization | | Queue backlog | Insufficient workers | Worker autoscaling | | LLM latency | Provider response time | Streaming and timeout controls | | High database connections | Too many replicas | Connection pooling | | Repeated context retrieval | Duplicate reads | Caching | ### 12.3 Performance Validation Proposed targets: * API p95 below 500 ms for non-LLM operations. * Monitor agent execution duration separately. * Monitor queue waiting time. * Track database query latency. * Measure token consumption per conversation. These are engineering targets, not measured results. ### PHASE 13: RELIABILITY & FAILURE-RECOVERY ENGINEERING ### 13.1 Failure Mode Analysis | Failure | Expected behavior | Recovery | | ------------------------ | ---------------------------------------- | ------------------ | | LLM unavailable | Return controlled error or safe fallback | Retry with limits | | Redis unavailable | Reject or defer queue-dependent tasks | Restore Redis | | Worker crash | Task becomes recoverable | Requeue safely | | PostgreSQL outage | Stop writes safely | Database recovery | | Commerce API failure | Show temporary unavailable status | Retry | | Duplicate refund request | Prevent duplicate transaction | Idempotency | | Agent timeout | Mark execution timed out | Controlled restart | ### 13.2 Reliability Controls * Circuit breakers. * Exponential backoff. * Idempotency keys. * Execution checkpoints. * Dead-letter queues. * Graceful degradation. * Database backups. * Recovery testing. ### 13.3 Critical Refund Scenario * Customer requests refund. * Agent verifies customer and order ownership. * Backend checks refund eligibility. * System checks whether a refund already exists. * High-value refund requires human approval. * Payment provider receives an idempotent request. * Provider response is recorded. * Customer receives a status update. The system must not interpret a network timeout as proof that a refund failed. It must reconcile provider transaction status before retrying. ### PHASE 14: OBSERVABILITY & OPERATIONAL MONITORING ### 14.1 Monitoring Stack Recommended components: * OpenTelemetry for instrumentation. * Prometheus for metrics. * Grafana for dashboards. * Centralized structured logging. * Error tracking platform. ### 14.2 Important Metrics | Metric | Purpose | | -------------------- | ---------------------------- | | API request rate | Traffic | | API p95 latency | Performance | | HTTP error rate | Reliability | | Queue depth | Worker capacity | | Agent execution time | Agent performance | | LLM latency | Model performance | | Token consumption | Cost | | Tool failure rate | Integration health | | Database connections | Capacity | | Refund failures | Business-critical operations | ### 14.3 Distributed Trace ```text Request ID: req_1001 | +-- Authentication | +-- Conversation Retrieval | +-- Agent Orchestration | | | +-- LLM Request | | | +-- Order API | +-- Database Persistence | +-- Response Delivery ``` Sensitive customer data and prompts should not be indiscriminately included in logs. ### PHASE 15: DEPLOYMENT & INFRASTRUCTURE ARCHITECTURE ### 15.1 Recommended Infrastructure | Layer | Technology | | ---------- | ---------------------------- | | Frontend | React | | Backend | FastAPI | | Database | Managed PostgreSQL | | Cache | Managed Redis | | Worker | Celery | | Container | Docker | | Storage | S3-compatible object storage | | Monitoring | Prometheus and Grafana | | Deployment | Managed container hosting | ### 15.2 Deployment Diagram ```mermaid flowchart TD A[Internet] --> B[Load Balancer] B --> C[FastAPI Containers] C --> D[(Managed PostgreSQL)] C --> E[(Managed Redis)] E --> F[Celery Workers] F --> G[LLM Provider] F --> H[E-commerce APIs] C --> I[Object Storage] C --> J[Monitoring] F --> J ``` ### 15.3 Environment Strategy * Development: Local Docker Compose. * Testing: Isolated test database and Redis. * Staging: Production-like configuration. * Production: Managed infrastructure with backups and monitoring. Kubernetes is not required for the initial deployment. ### PHASE 16: CI/CD & RELEASE ENGINEERING ### 16.1 Recommended Pipeline ```mermaid flowchart TD A[Developer Push] --> B[GitHub Repository] B --> C[Lint and Type Checks] C --> D[Unit Tests] D --> E[Integration Tests] E --> F[Security Scan] F --> G[Docker Build] G --> H[Staging Deployment] H --> I[Smoke Tests] I --> J[Production Approval] J --> K[Production Deployment] ``` ### 16.2 Pipeline Requirements * Git-based version control. * Feature branches. * Automated linting. * Unit and integration tests. * Dependency vulnerability scanning. * Docker image scanning. * Database migrations. * Staging validation. * Production approval. * Rollback procedure. ### 16.3 Database Migration Safety Use backward-compatible migrations: * Add new nullable columns. * Deploy compatible application code. * Backfill data. * Validate results. * Apply constraints. * Remove obsolete fields in a later release. ### PHASE 17: TESTING & VALIDATION ARCHITECTURE ### 17.1 Testing Strategy | Test type | What to validate | | ----------------- | ------------------------------ | | Unit | Business logic | | Integration | Database and Redis | | API | Endpoint contracts | | Agent runtime | Agent execution | | Tool integration | External APIs | | Security | Authentication and permissions | | Tenant isolation | Data separation | | Load | Concurrent workloads | | Failure injection | Recovery behavior | ### 17.2 Sample Test Scenarios Test 1: Customer order tracking * Input: Customer asks for order status. * Expected: Correct order retrieved. * Validation: Customer ownership checked. Test 2: Unauthorized order access * Input: Customer requests another customer's order. * Expected: Access denied. * Validation: No information leakage. Test 3: Refund approval * Input: Customer requests a high-value refund. * Expected: Approval workflow triggered. * Validation: No refund executes before approval. Test 4: Duplicate refund request * Input: Same idempotency key submitted twice. * Expected: No duplicate refund. * Validation: One provider transaction. Test 5: Worker crash * Input: Worker terminates during execution. * Expected: Execution is safely recoverable. * Validation: No duplicate side effects. These are proposed tests, not executed test results. ### PHASE 18: COST & RESOURCE ARCHITECTURE ### 18.1 Cost Categories | Resource | Cost driver | | --------------- | ------------------------- | | Backend hosting | CPU and memory | | PostgreSQL | Storage and connections | | Redis | Memory and throughput | | Celery workers | Execution volume | | LLM API | Tokens and model choice | | Object storage | Files and downloads | | Monitoring | Metrics and log retention | | External APIs | Third-party usage | ### 18.2 Cost Optimization * Use smaller models for simple classification. * Use advanced models only for complex tasks. * Limit unnecessary conversation context. * Cache frequently requested product data. * Set tenant-specific token budgets. * Control worker concurrency. * Archive old logs according to retention policy. ### 18.3 Budget Planning For an MVP, compare: * Managed application hosting. * Managed PostgreSQL. * Managed Redis. * Object storage. * LLM usage. * Monitoring. Actual costs must be calculated using the selected provider, region, usage assumptions, and current pricing. ### PHASE 19: IMPLEMENTATION ROADMAP & ENGINEERING TASK BREAKDOWN ### Phase A: Foundation | Task ID | Task | Priority | Complexity | | ------- | ------------------------------ | -------- | ---------- | | A01 | Initialize FastAPI project | Critical | Low | | A02 | Configure PostgreSQL | Critical | Medium | | A03 | Setup Docker | High | Low | | A04 | Configure environment settings | High | Low | | A05 | Implement authentication | Critical | Medium | ### Phase B: Core Backend | Task ID | Task | Priority | Complexity | | ------- | --------------------------- | -------- | ---------- | | B01 | Create user models | Critical | Medium | | B02 | Implement tenant management | Critical | High | | B03 | Build agent management API | High | Medium | | B04 | Build conversation API | High | Medium | | B05 | Implement execution records | Critical | Medium | ### Phase C: Agent Infrastructure | Task ID | Task | Priority | Complexity | | ------- | ------------------------- | -------- | ---------- | | C01 | Build agent orchestrator | Critical | High | | C02 | Create LLM adapter | Critical | Medium | | C03 | Implement product agent | High | Medium | | C04 | Implement order agent | High | High | | C05 | Implement refund workflow | Critical | High | | C06 | Configure Celery workers | High | Medium | ### Phase D: Production Features | Task ID | Task | Priority | Complexity | | ------- | ------------------------ | -------- | ---------- | | D01 | Add rate limiting | High | Medium | | D02 | Add audit logging | Critical | Medium | | D03 | Add monitoring | High | Medium | | D04 | Add usage tracking | Medium | Medium | | D05 | Implement recovery logic | Critical | High | ### Phase E: Deployment | Task ID | Task | Priority | Complexity | | ------- | -------------------------------- | -------- | ---------- | | E01 | Prepare production Docker images | High | Medium | | E02 | Configure staging | High | Medium | | E03 | Build CI/CD pipeline | High | High | | E04 | Configure backups | Critical | Medium | | E05 | Production deployment | Critical | High | ### Phase F: Validation | Task ID | Task | Priority | Complexity | | ------- | ------------------------ | -------- | ---------- | | F01 | API testing | High | Medium | | F02 | Tenant isolation testing | Critical | High | | F03 | Agent runtime testing | Critical | High | | F04 | Load testing | High | High | | F05 | Security review | Critical | High | Dependency rule: Foundation must be completed before core backend implementation. Agent infrastructure depends on persistent execution records and integration interfaces. ### PHASE 20: FINAL BACKEND ARCHITECTURE DOCUMENTATION ### Document A: System Architecture * Modular FastAPI backend. * Multi-agent orchestrator. * Independent asynchronous workers. * PostgreSQL primary storage. * Redis coordination and caching. * External LLM and commerce integrations. ### Document B: API Design * Versioned REST API. * JWT or OIDC authentication. * Pydantic validation. * Standardized errors. * Idempotency for sensitive operations. * OpenAPI documentation. ### Document C: Data Architecture * Relational data in PostgreSQL. * Tenant-aware records. * JSONB for flexible configurations. * Optional pgvector for semantic retrieval. * Object storage for files. ### Document D: Agent Runtime * Supervisor-based orchestration. * Specialized agents. * Persistent execution states. * Tool permission boundaries. * Background processing. * Failure recovery. ### Document E: Security * Authentication and RBAC. * Tenant isolation. * Secret management. * Prompt injection defenses. * Tool allowlisting. * Human approval workflows. * Audit logs. ### Document F: Production Infrastructure * Docker containers. * Managed PostgreSQL and Redis. * Celery workers. * Monitoring and tracing. * CI/CD. * Backup and restore strategy. ### Document G: Engineering Roadmap * Foundation. * Core backend. * Agent runtime. * Production features. * Deployment. * Validation. ### Document H: Architecture Decision Records | ADR | Decision | Reason | | ------- | ---------------------- | ------------------------ | | ADR-001 | Modular monolith | Lower complexity | | ADR-002 | PostgreSQL | Relational consistency | | ADR-003 | Redis + Celery | Background execution | | ADR-004 | Shared tenant database | Cost efficiency | | ADR-005 | Agent orchestrator | Centralized coordination | | ADR-006 | Docker | Portable deployment | | ADR-007 | Managed infrastructure | Lower operational burden | ### Example ADR: Modular Monolith Context: The product is an early-stage multi-agent platform. Decision: Deploy one modular API application with separately scalable workers. Alternatives: Microservices and serverless. Advantages: Simpler deployment and development. Disadvantages: Requires strict module boundaries. Reconsider when: Independent teams, scaling requirements, security isolation, or deployment needs justify service extraction. ### PHASE 21: FINAL ARCHITECTURE REVIEW ### 21.1 Architecture Assessment Architecture Design: Approved for Detailed Implementation Planning This is a proposed design assessment, not a production certification. | Review criterion | Assessment | | ---------------------- | ------------------- | | Requirements alignment | Strong | | Service boundaries | Defined | | Agent runtime | Defined | | API contracts | Drafted | | Database ownership | Defined | | Async workflows | Defined | | Tenant isolation | Designed | | Security | Designed | | Scalability | Planned | | Failure recovery | Planned | | Observability | Planned | | Deployment | Planned | | Cost considerations | Addressed | | Implementation roadmap | Defined | | Production readiness | Requires validation | ### 21.2 Architectural Strengths * Centralized multi-agent orchestration. * Clear database ownership. * Controlled tool execution. * Tenant-aware data access. * Asynchronous task processing. * Practical MVP deployment model. * Explicit refund approval workflow. ### 21.3 Critical Risks * Prompt injection through product or customer content. * Unauthorized refund execution. * Cross-tenant data exposure. * Duplicate external API operations. * LLM provider outages. * Queue backlog during traffic spikes. * Excessive LLM token consumption. ### 21.4 Missing Components Before Production * Formal data protection and retention policy. * Payment provider reconciliation. * Disaster recovery objectives (RPO and RTO). * Detailed OpenAPI specification. * Independent penetration testing. * Tested backup restoration. * Load-test evidence. * Operational incident response procedures. ### 21.5 Final Engineering Recommendations Priority 1: Authentication, authorization, and tenant isolation. Priority 2: Reliable agent execution and persistent state. Priority 3: Secure external tool integrations. Priority 4: Refund idempotency and human approval. Priority 5: Monitoring, recovery, and deployment automation. Priority 6: Performance and infrastructure optimization. ### 🏆 FINAL TEST RESULT ### 21 / 21 Architecture phases covered Requirements analysis Covered Backend and agent architecture Covered API and database engineering Covered Security and scalability Covered Deployment and CI/CD Covered Testing and implementation roadmap Covered Final architecture review Covered Final verdict: The prompt successfully produces an implementation-oriented architecture blueprint covering all 21 phases. The output includes system diagrams, SQL, JSON contracts, agent lifecycle, security controls, infrastructure decisions, and engineering tasks. Important quality distinction: This sample demonstrates architecture design, not actual code implementation, deployment, load testing, or verified production readiness.
Claude

Agent Backend Architecture Engineer

Add to Cart
Instant accessInstant access
Usage rightsCommercial use
Money-back guaranteeMoney‑back
By purchasing this prompt, you agree to our terms of service
CLAUDE-5-5-SONNET
Tested icon
Guide icon
4 examples icon
Free credits icon
Building a production-ready AI agent application requires much more than connecting an LLM to an API. You need a reliable backend architecture, well-defined service boundaries, database systems, agent execution infrastructure, secure API contracts, asynchronous processing, and scalable system design. Design the architecture. Engineer the infrastructure. Build for production.
...more
Added 6 days ago
Report
Browse Marketplace