diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 0000000..37800b3 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,38 @@ +--- +name: Bug report +about: Create a report to help us improve +title: '' +labels: bug +assignees: '' + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**To Reproduce** +Steps to reproduce the behavior: +1. Go to '...' +2. Click on '...' +3. Scroll down to '...' +4. See error + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Screenshots** +If applicable, add screenshots to help explain your problem. + +**Desktop (please complete the following information):** + - OS: [e.g. iOS] + - Browser [e.g. chrome, safari] + - Version [e.g. 22] + +**Smartphone (please complete the following information):** + - Device: [e.g. iPhone6] + - OS: [e.g. iOS8.1] + - Browser [e.g. stock browser, safari] + - Version [e.g. 22] + +**Additional context** +Add any other context about the problem here. diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000..11fc491 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,20 @@ +--- +name: Feature request +about: Suggest an idea for this project +title: '' +labels: enhancement +assignees: '' + +--- + +**Is your feature request related to a problem? Please describe.** +A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] + +**Describe the solution you'd like** +A clear and concise description of what you want to happen. + +**Describe alternatives you've considered** +A clear and concise description of any alternative solutions or features you've considered. + +**Additional context** +Add any other context or screenshots about the feature request here. diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000..d5466f7 --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,71 @@ +# Pull Request + +## Description + + +## Type of Change + +- [ ] πŸ› Bug fix (non-breaking change that fixes an issue) +- [ ] ✨ New feature (non-breaking change that adds functionality) +- [ ] πŸ’₯ Breaking change (fix or feature that would cause existing functionality to change) +- [ ] πŸ“š Documentation update +- [ ] πŸ”§ Configuration change +- [ ] ♻️ Refactor (no functional changes) +- [ ] πŸ—οΈ Infrastructure/IaC change + +## Related Issues + +Closes # + +## Changes Made + +- + +## Infrastructure Changes (if applicable) + +- [ ] Terraform files modified +- [ ] New cloud resources added +- [ ] Security groups/IAM policies changed +- [ ] Cost impact assessed + +### IaC Details + +``` +terraform plan output or summary here +``` + +## Testing + +- [ ] Unit tests pass +- [ ] Integration tests pass +- [ ] Manual testing completed +- [ ] IaC validation (`terraform validate`) passes + +### Test Evidence + + +## Checklist + +- [ ] My code follows the project's coding standards +- [ ] I have performed a self-review of my code +- [ ] I have commented my code, particularly in hard-to-understand areas +- [ ] I have made corresponding changes to the documentation +- [ ] My changes generate no new warnings or errors +- [ ] I have added tests that prove my fix/feature works +- [ ] New and existing unit tests pass locally +- [ ] Any dependent changes have been merged and published + +## CodeRabbit Review + +- [ ] I have addressed all CodeRabbit suggestions +- [ ] Critical security/performance issues resolved +- [ ] IaC best practices followed (for infrastructure changes) + +## Screenshots (if applicable) + + +## Additional Notes + + +--- +*This PR will be automatically reviewed by [CodeRabbit](https://coderabbit.ai) 🐰* diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a8a368f..6435c4a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,4 +1,4 @@ -name: ci +name: CI on: pull_request: @@ -6,25 +6,57 @@ on: branches: [main, dev] jobs: - test: + test-python: + name: Python Tests runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 + - name: Set up Python uses: actions/setup-python@v5 with: python-version: "3.11" - - name: Install Python deps + + - name: Install dependencies run: | python -m pip install --upgrade pip - pip install fastapi uvicorn pytest - - name: Run unit tests (placeholder) - run: | - pytest || true - - name: Terraform fmt/validate (placeholder) - run: | - echo "terraform fmt/validate would run here" - - name: Secret scan (placeholder) + pip install -r requirements.txt + + - name: Run Python tests + run: pytest tests/ -v --ignore=tests/test_kestra.js --ignore=tests/test-all-tools.mjs + + test-mcp-server: + name: MCP Server Build + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Set up Node.js + uses: actions/setup-node@v4 + with: + node-version: "20" + + - name: Install and build MCP server + working-directory: infoundry-mcp-server run: | - echo "gitleaks/trufflehog would run here" + npm ci + npm run build + + lint-ui: + name: UI Lint + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Set up Node.js + uses: actions/setup-node@v4 + with: + node-version: "20" + + - name: Install UI dependencies + working-directory: ui + run: npm ci + - name: Run linter + working-directory: ui + run: npm run lint || true # Don't fail on lint warnings diff --git a/.github/workflows/coderabbit.yml b/.github/workflows/coderabbit.yml new file mode 100644 index 0000000..d949a3d --- /dev/null +++ b/.github/workflows/coderabbit.yml @@ -0,0 +1,232 @@ +name: CodeRabbit Review + +on: + pull_request: + types: [opened, synchronize, reopened, ready_for_review] + pull_request_review_comment: + types: [created] + +# Ensure we have necessary permissions for CodeRabbit +permissions: + contents: read + pull-requests: write + issues: write + +jobs: + # CodeRabbit automatically reviews PRs when configured in the repo + # This job validates IaC and blocks merge on failures + iac-validation: + name: IaC Validation Gate + runs-on: ubuntu-latest + # Only run for pull_request events (not pull_request_review_comment) and skip drafts + if: github.event_name == 'pull_request' && github.event.pull_request.draft == false + + steps: + - name: Checkout Code + uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Check for Terraform Changes + id: tf-changes + run: | + # Get list of changed files + if [ "${{ github.event_name }}" == "pull_request" ]; then + CHANGED_FILES=$(git diff --name-only origin/${{ github.base_ref }}...HEAD) + else + CHANGED_FILES=$(git diff --name-only HEAD~1) + fi + + # Check if any .tf files are changed + TF_CHANGED=$(echo "$CHANGED_FILES" | grep -E '\.tf$' || true) + + if [ -n "$TF_CHANGED" ]; then + echo "terraform_changed=true" >> $GITHUB_OUTPUT + echo "πŸ“¦ Terraform files changed:" + echo "$TF_CHANGED" + else + echo "terraform_changed=false" >> $GITHUB_OUTPUT + echo "ℹ️ No Terraform files changed" + fi + + - name: Setup Terraform + if: steps.tf-changes.outputs.terraform_changed == 'true' + uses: hashicorp/setup-terraform@v3 + with: + terraform_version: "1.6.0" + + - name: Terraform Format Check + if: steps.tf-changes.outputs.terraform_changed == 'true' + id: fmt + run: | + echo "πŸ” Checking Terraform formatting..." + terraform fmt -check -recursive -diff + continue-on-error: true + + - name: Find Terraform Directories + if: steps.tf-changes.outputs.terraform_changed == 'true' + id: tf-dirs + run: | + # Find all directories containing .tf files + TF_DIRS=$(find . -name "*.tf" -type f -exec dirname {} \; | sort -u | grep -v '.terraform' || true) + echo "tf_dirs<> $GITHUB_OUTPUT + echo "$TF_DIRS" >> $GITHUB_OUTPUT + echo "EOF" >> $GITHUB_OUTPUT + echo "πŸ“‚ Terraform directories found:" + echo "$TF_DIRS" + + - name: Terraform Init & Validate + if: steps.tf-changes.outputs.terraform_changed == 'true' + id: validate + run: | + VALIDATION_FAILED=false + + while IFS= read -r dir; do + if [ -n "$dir" ] && [ -d "$dir" ]; then + echo "πŸ“ Validating: $dir" + cd "$dir" + + # Initialize (backend disabled for validation only) + terraform init -backend=false -input=false 2>/dev/null || true + + # Validate + if ! terraform validate; then + echo "❌ Validation failed for: $dir" + VALIDATION_FAILED=true + else + echo "βœ… Validation passed for: $dir" + fi + + cd - > /dev/null + fi + done <<< "${{ steps.tf-dirs.outputs.tf_dirs }}" + + if [ "$VALIDATION_FAILED" = true ]; then + echo "validation_status=failed" >> $GITHUB_OUTPUT + exit 1 + else + echo "validation_status=passed" >> $GITHUB_OUTPUT + fi + + - name: TFLint Setup + if: steps.tf-changes.outputs.terraform_changed == 'true' + uses: terraform-linters/setup-tflint@v4 + with: + tflint_version: latest + + - name: TFLint Scan + if: steps.tf-changes.outputs.terraform_changed == 'true' + id: tflint + run: | + echo "πŸ”Ž Running TFLint..." + + while IFS= read -r dir; do + if [ -n "$dir" ] && [ -d "$dir" ]; then + echo "πŸ“ Linting: $dir" + cd "$dir" + tflint --init 2>/dev/null || true + tflint --format=compact || true + cd - > /dev/null + fi + done <<< "${{ steps.tf-dirs.outputs.tf_dirs }}" + continue-on-error: true + + - name: Security Scan with tfsec + if: steps.tf-changes.outputs.terraform_changed == 'true' + uses: aquasecurity/tfsec-action@v1.0.3 + with: + soft_fail: false + additional_args: --minimum-severity MEDIUM + + - name: Post Validation Summary + if: always() && steps.tf-changes.outputs.terraform_changed == 'true' + uses: actions/github-script@v7 + with: + script: | + const fmtStatus = '${{ steps.fmt.outcome }}' === 'success' ? 'βœ…' : '⚠️'; + const validateStatus = '${{ steps.validate.outcome }}' === 'success' ? 'βœ…' : '❌'; + + const body = `## πŸ” IaC Validation Results + + | Check | Status | + |-------|--------| + | Terraform Format | ${fmtStatus} ${{ steps.fmt.outcome }} | + | Terraform Validate | ${validateStatus} ${{ steps.validate.outcome }} | + | TFLint | ${{ steps.tflint.outcome == 'success' && 'βœ… passed' || '⚠️ warnings' }} | + | Security Scan (tfsec) | ${{ job.status == 'success' && 'βœ… passed' || '❌ issues found' }} | + + --- + *IaC validation is required to pass before merge. Please address any issues flagged above.* + *CodeRabbit will provide additional review comments on your changes.* 🐰`; + + github.rest.issues.createComment({ + issue_number: context.issue.number, + owner: context.repo.owner, + repo: context.repo.repo, + body: body + }); + + - name: Block Merge on IaC Failure + if: steps.validate.outcome == 'failure' + run: | + echo "❌ IaC validation failed. Merge is blocked." + echo "Please fix the Terraform validation errors before merging." + exit 1 + + # Quality gate - ensures CodeRabbit has reviewed + coderabbit-gate: + name: CodeRabbit Review Gate + runs-on: ubuntu-latest + # Only run for pull_request events (not pull_request_review_comment) and skip drafts + if: github.event_name == 'pull_request' && github.event.pull_request.draft == false + + steps: + - name: Check CodeRabbit Configuration + run: | + echo "🐰 CodeRabbit Review Gate" + echo "" + echo "This job ensures CodeRabbit integration is active." + echo "CodeRabbit will automatically review this PR and provide:" + echo " - Code quality suggestions" + echo " - Security recommendations" + echo " - Best practices feedback" + echo " - IaC-specific reviews for Terraform files" + echo "" + echo "βœ… Gate passed - CodeRabbit is configured to review all PRs" + + - name: Create Review Reminder + uses: actions/github-script@v7 + with: + script: | + // Check if we already commented + const comments = await github.rest.issues.listComments({ + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: context.issue.number, + }); + + const botComment = comments.data.find(comment => + comment.body.includes('CodeRabbit Review Reminder') + ); + + if (!botComment) { + const body = `## 🐰 CodeRabbit Review Reminder + + This PR will be automatically reviewed by CodeRabbit. Please ensure: + + - [ ] All CodeRabbit suggestions have been addressed + - [ ] Critical issues are resolved before requesting human review + - [ ] IaC changes follow security best practices + + > **Tip:** Reply to CodeRabbit comments with \`@coderabbitai\` to get clarifications or request re-reviews. + + --- + *Maintainer approval is required after addressing CodeRabbit feedback.*`; + + github.rest.issues.createComment({ + issue_number: context.issue.number, + owner: context.repo.owner, + repo: context.repo.repo, + body: body + }); + } diff --git a/.gitignore b/.gitignore index 26d0b60..86e0c5c 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,8 @@ __pycache__/ .pytest_cache/ .venv/ +.test_venv/ +venv/ env/ *.pyc .DS_Store @@ -11,3 +13,20 @@ build/ *.tfstate* /service_profile.json +# Logs +*.log +npm-debug.log* + +# IDE +.idea/ +.vscode/ +*.swp +*.swo + +# Test coverage +coverage/ +htmlcov/ +.coverage + +# Compiled files +*.egg-info/ diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..9e1d904 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,29 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [Unreleased] + +### Added +- `SECURITY.md` for security policy. +- Issue templates for bug reports and feature requests. +- `CHANGELOG.md` (this file). +- `ROADMAP.md` for project roadmap. + +### Changed +- None + +### Deprecated +- None + +### Removed +- None + +### Fixed +- None + +### Security +- None diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md index 197ccd5..1a43200 100644 --- a/CODE_OF_CONDUCT.md +++ b/CODE_OF_CONDUCT.md @@ -17,7 +17,7 @@ Maintainers are responsible for clarifying standards of acceptable behavior and This Code of Conduct applies within all project spaces and in public spaces when an individual is representing the project or its community. ## Enforcement -Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the maintainers at project@cloudgenesis.invalid. All complaints will be reviewed and investigated promptly. +Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the project maintainers. All complaints will be reviewed and investigated promptly. ## Attribution This Code of Conduct is adapted from the Contributor Covenant, version 2.1. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 3105c71..a41027c 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,26 +1,59 @@ -# Contributing to CloudGenesis +# Contributing to InFoundry Thank you for considering a contribution! This guide keeps contributions consistent and reviewable. -## Ground rules +## Ground Rules - Use Conventional Commits (feat, fix, chore, docs, refactor). - Keep PRs small and focused; include tests and docs when applicable. - Run linters/tests before pushing. - Follow the Code of Conduct. -## How to contribute +## How to Contribute 1. Fork the repo and create a feature branch: `git checkout -b feat/`. 2. Implement your change with accompanying tests and docs. -3. Run checks (see `ci/test.yml` guidance). +3. Run tests: `pytest tests/ -v`. 4. Submit a PR. Fill the template with context, testing evidence, and risk notes. 5. A maintainer and CodeRabbit must approve before merge. -## Development environment +## Development Environment - Python 3.11+, Node 18+. - Optional: Docker, kind, localstack. -- Install deps per `requirements.txt` (placeholder) and `ui/package.json` when available. +- Install deps: `pip install -r requirements.txt` and `cd ui && npm install`. -## Issues and discussions +## Issues and Discussions - Use issue templates for bugs and features. - Propose substantial design changes in a discussion or an RFC under `docs/`. +## CodeRabbit Review Guidelines + +All pull requests are automatically reviewed by [CodeRabbit](https://coderabbit.ai), our AI-powered code review assistant. + +### How It Works +1. **Automatic Review**: When you open a PR, CodeRabbit automatically analyzes your changes and posts review comments. +2. **IaC Validation**: For Terraform/infrastructure changes, CodeRabbit checks for security issues, best practices, and validation errors. +3. **Merge Blocking**: PRs with critical IaC validation failures will be blocked from merging until issues are resolved. + +### Interacting with CodeRabbit +- **Ask Questions**: Reply to any CodeRabbit comment with `@coderabbitai` to get clarification. +- **Request Re-review**: After making changes, comment `@coderabbitai review` to trigger a fresh review. +- **Dismiss Suggestions**: If a suggestion doesn't apply, explain why in a reply. +- **Generate Summaries**: Use `@coderabbitai summary` to get an overview of large PRs. + +### Addressing Feedback +1. **Critical Issues** (πŸ”΄): Must be fixed before merge. These typically involve security vulnerabilities, breaking changes, or validation failures. +2. **Suggestions** (🟑): Recommended improvements. Address these when possible, or explain why they don't apply. +3. **Nitpicks** (🟒): Minor style/code quality suggestions. Nice to fix but not blocking. + +### IaC-Specific Reviews +For infrastructure changes, CodeRabbit validates: +- Terraform syntax and formatting (`terraform fmt`, `terraform validate`) +- Security best practices via `tfsec` +- Linting rules via `TFLint` +- Cost and resource implications + +### Merge Requirements +A PR can only be merged when: +- [ ] CodeRabbit review is complete +- [ ] All critical issues are resolved +- [ ] IaC validation passes (for infrastructure changes) +- [ ] At least one maintainer approves diff --git a/LICENSE b/LICENSE index 65cd917..8b3f539 100644 --- a/LICENSE +++ b/LICENSE @@ -1,177 +1,21 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - -1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - -2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - -3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - -4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - -5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - -6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - -7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - -8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - -9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - -END OF TERMS AND CONDITIONS - +MIT License + +Copyright (c) 2025 InFoundry + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md index 507ba79..1daa22d 100644 --- a/README.md +++ b/README.md @@ -1,17 +1,87 @@ -# CloudGenesis +# InFoundry -CloudGenesis is a self-adaptive Cloud Architect + SRE agent that inspects a codebase and telemetry, proposes deployable IaC/CI changes, runs safe test deployments, and iteratively optimizes cost, latency, and reliability with human-in-the-loop approvals. +InFoundry is a self-adaptive Cloud Architect + SRE agent that inspects codebases and telemetry, proposes deployable IaC/CI changes, runs safe test deployments, and iteratively optimizes cost, latency, and reliability with human-in-the-loop approvals. -## Quick start -- Install Python 3.11+ and Node 18+. Optional: Docker, kind, localstack. -- Clone the repo, then: `pip install -r requirements.txt` (placeholder) and `npm install` inside `ui/` when it exists. -- Review `docs/BLUEPRINT.md` for the full architecture, plan, and implementation notes. -- Inspect sample telemetry under `examples/telemetry` and run the repo analyzer stub: `python orchestrator/repo_analyzer/scan.py`. -- Explore Kestra pipeline example at `orchestrator/kestra_pipelines/collect-and-summarize.yaml`. +## Features -## Structure -See `docs/BLUEPRINT.md` for the detailed structure and day-by-day plan. The scaffolded folders align with the requested layout (infra, services, orchestrator, ui, tests, examples, scripts, docs, .github/workflows). +- **AI-Powered Architecture Recommendations** - Uses fine-tuned Oumi model for intelligent cloud architecture decisions +- **Kestra Pipeline Orchestration** - End-to-end workflow from repo analysis to PR creation +- **MCP Server for Cline Integration** - Expose all tools via Model Context Protocol +- **React UI Dashboard** - Visual architecture editor with React Flow +- **IaC Generation** - Automatic Terraform generation for AWS -## Licensing -Released under Apache-2.0 (see `LICENSE`). +## Quick Start +### Prerequisites +- Python 3.11+ +- Node.js 18+ +- Optional: Docker, kind, localstack + +### Installation + +```bash +# Clone the repository +git clone https://github.com/your-org/infoundry.git +cd infoundry + +# Install Python dependencies +pip install -r requirements.txt + +# Install UI dependencies +cd ui && npm install && cd .. + +# Install MCP server dependencies +cd infoundry-mcp-server && npm install && npm run build && cd .. +``` + +### Run the UI +```bash +cd ui +cp .env.example .env.local +# Edit .env.local with your Kestra credentials if needed +npm run dev +# Open http://localhost:3000 +``` + +### Run the Oumi Server +```bash +cd oumi +python serve.py +# API available at http://localhost:8000 +``` + +## Project Structure + +``` +infoundry/ +β”œβ”€β”€ docs/ # Documentation +β”œβ”€β”€ examples/ # Sample data files +β”œβ”€β”€ infoundry-mcp-server/ # Cline MCP integration +β”œβ”€β”€ orchestrator/ # Kestra pipeline definitions +β”œβ”€β”€ oumi/ # AI model training & serving +β”œβ”€β”€ scripts/ # Utility scripts +β”œβ”€β”€ tests/ # Unit tests +└── ui/ # Next.js React dashboard +``` + +## Documentation + +- [Blueprint & Architecture](docs/BLUEPRINT.md) - Full system design +- [Kestra Architecture](docs/kestra-architecture.md) - Pipeline documentation +- [Oumi Model](oumi/README.md) - AI model training guide +- [MCP Server](infoundry-mcp-server/README.md) - Cline integration + +## Testing + +```bash +# Python tests +pip install pytest fastapi httpx +pytest tests/ -v + +# MCP server tests +node tests/test_mcp_server.mjs +``` + +## License + +Released under the [MIT License](LICENSE). diff --git a/ROADMAP.md b/ROADMAP.md new file mode 100644 index 0000000..40ca853 --- /dev/null +++ b/ROADMAP.md @@ -0,0 +1,17 @@ +# Roadmap + +This document outlines the high-level roadmap for InFoundry. + +## 2026 Q1 +- [ ] Implement enhanced authentication. +- [ ] Add support for more cloud providers. +- [ ] Improve visualization capabilities. + +## 2026 Q2 +- [ ] Automated compliance auditing. +- [ ] Integration with major CI/CD platforms. +- [ ] Advanced cost estimation features. + +## Future Ideas +- AI-driven architecture optimization. +- Collaborative real-time editing. diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 0000000..995a6b8 --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,18 @@ +# Security Policy + +## Supported Versions + +Use this section to tell people about which versions of your project are currently being supported with security updates. + +| Version | Supported | +| ------- | ------------------ | +| 1.0.x | :white_check_mark: | +| < 1.0 | :x: | + +## Reporting a Vulnerability + +Use this section to tell people how to report a vulnerability. + +Tell them where to go, how often they can expect to get an update on a reported vulnerability, what to expect if the vulnerability is accepted or rejected, etc. + +To report a vulnerability, please email [security@infoundry.com](mailto:security@infoundry.com). diff --git a/docs/BLUEPRINT.md b/docs/BLUEPRINT.md index c830361..fb08aec 100644 --- a/docs/BLUEPRINT.md +++ b/docs/BLUEPRINT.md @@ -1,260 +1,502 @@ -# CloudGenesis Blueprint (copy-paste friendly) - -This blueprint is a complete plan for building CloudGenesis as an open-source, human-in-the-loop cloud architect + SRE agent. It includes architecture, repo layout, 7-day plan, CI/CD, Oumi training notes, Kestra pipelines, Cline + CodeRabbit integration, security, metrics, demo script, and stretch goals. - -## Table of contents -1. What CloudGenesis does (short) -2. High-level architecture (text diagram) -3. Component responsibilities -4. Repo structure (copyable) -5. Development stack & prerequisites -6. Step-by-step 7-day build plan -7. Example configs & code snippets -8. CI/CD, testing, and quality gates -9. Best open-source practices & contributor workflow -10. Security, privacy & safety checklist -11. Metrics, evaluation & judging criteria -12. Demo script (3–5 minutes) -13. Hardest technical challenges + mitigations -14. Stretch goals & future roadmap -15. Quick start checklist - -## 1) What CloudGenesis does (short) -- Reads a repo and runtime telemetry. -- Proposes infra changes (IaC, autoscaling, DB indexes, instance types). -- Generates PRs via Cline and submits to CodeRabbit for review. -- Runs simulated/test deployments, collects metrics via Kestra. -- Uses Oumi (SFT + simple RL) to rank/choose actions and improve over time. -- Shows actions, estimated impact, and before/after results in a Vercel UI. - -## 2) High-level architecture (text diagram) +# InFoundry Blueprint + +This document provides the complete system design blueprint for InFoundry, including project structure, component specifications, and implementation details. + +## Project Structure + ``` -[Repo + Codebase] --> Repo Analyzer - | - v - Kestra Ingest & Summaries - (metrics/traces/logs/billing/slow-queries -> structured summary) - | - v - Decision Model (Oumi) - | - +------------+-----------+------------+--------------+ - | | | | - v v v v -Cline (Generate) -> PR -> CodeRabbit (Review) -> Merge/Deploy - | - v - Simulation Runner / Test Env - | - v - Observability (Prom/OTel) - | - v - Kestra collects results (loop) +infoundry/ +β”œβ”€β”€ docs/ # Documentation +β”‚ β”œβ”€β”€ architecture.md # System architecture overview +β”‚ β”œβ”€β”€ blueprint.md # This file - system design +β”‚ └── runlocally.md # Local development guide +β”‚ +β”œβ”€β”€ examples/ # Sample data files +β”‚ β”œβ”€β”€ sample_architecture_plan.json +β”‚ β”œβ”€β”€ sample_deploy_result.json +β”‚ β”œβ”€β”€ sample_graph.json +β”‚ β”œβ”€β”€ sample_pr_result.json +β”‚ β”œβ”€β”€ sample_service_profile.json +β”‚ β”œβ”€β”€ sample_telemetry_summary.json +β”‚ └── sft_examples.jsonl # Training examples +β”‚ +β”œβ”€β”€ infoundry-mcp-server/ # Cline MCP integration +β”‚ β”œβ”€β”€ src/ +β”‚ β”‚ └── index.ts # MCP server implementation +β”‚ β”œβ”€β”€ package.json +β”‚ └── tsconfig.json +β”‚ +β”œβ”€β”€ orchestrator/ # Kestra pipeline definitions +β”‚ └── kestra_pipelines/ +β”‚ β”œβ”€β”€ 00-end-to-end.yaml # Master pipeline +β”‚ β”œβ”€β”€ 01-ingest-repo.yaml +β”‚ β”œβ”€β”€ 02-ingest-telemetry.yaml +β”‚ β”œβ”€β”€ 03-propose-architecture.yaml +β”‚ β”œβ”€β”€ 04-render-graph.yaml +β”‚ β”œβ”€β”€ 05-generate-iac.yaml +β”‚ β”œβ”€β”€ 06-validate-iac.yaml +β”‚ β”œβ”€β”€ 07-create-pr.yaml +β”‚ β”œβ”€β”€ 08-validate-pr.yaml +β”‚ β”œβ”€β”€ 09-evaluate.yaml +β”‚ └── namespace.yaml +β”‚ +β”œβ”€β”€ oumi/ # AI model training & serving +β”‚ β”œβ”€β”€ serve.py # FastAPI model server +β”‚ β”œβ”€β”€ train_sft.py # SFT training script +β”‚ β”œβ”€β”€ run_inference.py # Model testing +β”‚ β”œβ”€β”€ generate_training_data.py # Training data generator +β”‚ β”œβ”€β”€ generate_with_oumi.py # Model-based data generator +β”‚ β”œβ”€β”€ InFoundry_Cloud_Training.ipynb # Colab notebook +β”‚ β”œβ”€β”€ generated_training_data.jsonl +β”‚ └── trained_model/ # LoRA adapter weights +β”‚ +β”œβ”€β”€ scripts/ # Utility scripts +β”‚ └── generate-pr.sh +β”‚ +β”œβ”€β”€ tests/ # Unit tests +β”‚ β”œβ”€β”€ test_generate_training_data.py +β”‚ β”œβ”€β”€ test_kestra.js +β”‚ β”œβ”€β”€ test_mcp_server.mjs +β”‚ └── test_oumi_serve.py +β”‚ +β”œβ”€β”€ ui/ # Next.js React dashboard +β”‚ β”œβ”€β”€ app/ # App Router pages +β”‚ β”‚ β”œβ”€β”€ page.jsx # Landing page +β”‚ β”‚ β”œβ”€β”€ layout.jsx +β”‚ β”‚ β”œβ”€β”€ globals.css +β”‚ β”‚ β”œβ”€β”€ api/ # API routes +β”‚ β”‚ β”œβ”€β”€ configure/ +β”‚ β”‚ β”œβ”€β”€ dashboard/ +β”‚ β”‚ └── pipeline/ +β”‚ β”œβ”€β”€ components/ # React components +β”‚ β”‚ β”œβ”€β”€ PipelineForm.jsx +β”‚ β”‚ β”œβ”€β”€ StepProgressBar.jsx +β”‚ β”‚ β”œβ”€β”€ StepOutputCard.jsx +β”‚ β”‚ └── viewers/ +β”‚ └── lib/ +β”‚ └── kestra.js # Kestra API client +β”‚ +β”œβ”€β”€ requirements.txt # Python dependencies +β”œβ”€β”€ README.md +β”œβ”€β”€ LICENSE +β”œβ”€β”€ CHANGELOG.md +β”œβ”€β”€ CODE_OF_CONDUCT.md +β”œβ”€β”€ CONTRIBUTING.md +β”œβ”€β”€ ROADMAP.md +└── SECURITY.md ``` -## 3) Component responsibilities -- **Repo Analyzer (Python/Node):** Static detection of services, Dockerfiles, frameworks, DB usage, heavy endpoints. Outputs JSON service profiles. -- **Kestra:** Aggregates telemetry (Prometheus, traces, logs, billing mock) and summarizes into compact inputs for Oumi (`summary.json`). -- **Oumi:** SFT + optional GRPO RL for multi-objective reward; returns ranked actions. -- **Cline CLI:** Renders IaC/Helm/Terraform, smoke-test harnesses, creates PRs programmatically. -- **CodeRabbit:** PR gate for Terraform plan, terratest, secret scanning, migration safety, style, tests. -- **Simulation Runner (localstack/kind):** Applies IaC in a safe environment; runs smoke and synthetic load tests (k6/vegeta). -- **Vercel UI (Next.js):** Project overview, recommendations, PR monitor, before/after charts, manual approvals. +## Component Specifications + +### 1. Oumi AI Model + +**Purpose:** Intelligent cloud architecture recommendations + +**Specification:** +- **Base Model:** Qwen/Qwen2.5-1.5B-Instruct +- **Fine-tuning Method:** LoRA (Low-Rank Adaptation) +- **Training Examples:** 500 +- **Output Format:** JSON with architecture pattern, components, and rationale + +**API Contract (`/v1/chat/completions`):** + +```typescript +// Request +interface CompletionRequest { + model: string; // Default: "codellama" + messages?: Message[]; // Chat messages + prompt?: string; // Direct prompt + max_tokens?: number; // Default: 2000 + temperature?: number; // Default: 0.7 +} + +// Response +interface CompletionResponse { + id: string; + choices: [{ + message: { + role: "assistant"; + content: string; // JSON architecture recommendation + }; + finish_reason: "stop"; + }]; +} +``` + +**Architecture Output Schema:** +```json +{ + "pattern": "serverless|microservices_ecs|kubernetes|event_driven|lift_and_shift", + "components": ["api_gateway", "lambda", "rds", "..."], + "topology": "N services with PATTERN on CLOUD", + "scaling_strategy": "horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa|vertical_scaling", + "estimated_cost_tier": "low|medium|high", + "rationale": "Explanation of architecture choice" +} +``` + +### 2. Kestra Pipelines + +**Purpose:** Orchestrate the complete IaC generation workflow + +**Pipeline Inputs (`00-end-to-end.yaml`):** + +| Input | Type | Required | Default | Description | +|-------|------|----------|---------|-------------| +| `repo_url` | STRING | Yes | - | Git repository URL | +| `branch` | STRING | Yes | "main" | Git branch to clone | +| `repository` | STRING | Yes | "crypticsaiyan/infotest" | GitHub repo for PR (owner/repo) | +| `cloud_provider` | STRING | Yes | "aws" | Target cloud (aws, gcp, azure) | +| `project_name` | STRING | Yes | "infoundry" | Project name for resources | +| `target_folder` | STRING | Yes | "infra" | Target folder for Terraform | +| `skip_pr` | BOOLEAN | Yes | false | Skip PR creation | +| `skip_validation` | BOOLEAN | Yes | false | Skip validation step | + +**Pipeline Outputs:** + +| Output | Type | Description | +|--------|------|-------------| +| `service_profile` | FILE | Repository analysis results | +| `architecture_plan` | FILE | AI-proposed architecture | +| `graph` | FILE | React Flow graph JSON | +| `iac_bundle` | FILE | Generated Terraform ZIP | +| `iac_manifest` | FILE | IaC generation manifest | + +**Kestra Namespace:** `infoundry` -## 4) Repo structure (copyable) +### 3. MCP Server + +**Purpose:** Expose InFoundry tools to Cline CLI + +**Tools Specification:** + +#### Tool: `ingest_repo` +```typescript +{ + repoPath: string; // Local path OR GitHub URL +} +// Returns: ServiceProfile JSON ``` -cloudgenesis/ -β”œβ”€ infra/ # IaC templates (Terraform / Helm) -β”‚ β”œβ”€ templates/ -β”‚ └─ modules/ -β”œβ”€ services/ # Example microservices (auth, payments) -β”‚ β”œβ”€ auth/ -β”‚ └─ payments/ -β”œβ”€ orchestrator/ # main controller (FastAPI / Express) -β”‚ β”œβ”€ repo_analyzer/ -β”‚ β”œβ”€ kestra_pipelines/ -β”‚ β”œβ”€ cline_integration/ -β”‚ └─ oumi_integration/ -β”œβ”€ tests/ # smoke tests, integration tests, load scripts -β”œβ”€ examples/ # mock telemetry + SFT examples -β”‚ β”œβ”€ telemetry/ -β”‚ └─ sft_examples.jsonl -β”œβ”€ ui/ # Next.js (Vercel) app -β”‚ β”œβ”€ pages/ -β”‚ └─ components/ -β”œβ”€ scripts/ -β”‚ β”œβ”€ simulate_load.py -β”‚ └─ compute_reward.py -β”œβ”€ .github/ -β”‚ └─ workflows/ # CI workflows -β”œβ”€ docs/ -β”‚ └─ CONTRIBUTING.md -└─ README.md + +#### Tool: `ingest_telemetry` +```typescript +{ + services: string; // Comma-separated service names + metricsJson?: string; // Optional real metrics JSON +} +// Returns: TelemetrySummary JSON ``` -## 5) Development stack & prerequisites -- Python 3.11+ (or 3.10) and Node.js 18+. -- Orchestrator: FastAPI (Python) or Express (Node). -- Kestra: local or mocked pipeline YAML (Kestra server optional). -- Oumi: Oumi CLI/API; SFT + LoRA for MVP. -- Cline: CLI + API token (sponsor tool). -- CodeRabbit: GitHub app integration (sponsor tool). -- IaC: Terraform or Helm (k8s via kind). -- Simulation: localstack for AWS or kind for k8s. -- Monitoring: Prometheus + OpenTelemetry + Grafana (or simulated metrics JSON). -- Testing: Pytest / Jest, Terratest/terraform plan, k6 for load. - -## 6) Step-by-step 7-day build plan (tasks per day) -- **Day 0 (prep):** Repo, GH Actions, README, LICENSE, CODE_OF_CONDUCT, CONTRIBUTING, Vercel link, install Cline, set CodeRabbit creds. -- **Day 1:** Sample services (auth, payments); repo_analyzer `scan.py` β†’ `service_profile.json`; example telemetry; simple Next.js page showing profile. -- **Day 2:** Kestra pipeline to ingest telemetry β†’ `summary.json`; summary script computing p50/p95/error_rate/cost; `/summaries` endpoint. -- **Day 3:** Build `examples/sft_examples.jsonl` (50–200 pairs); `oumi_train.yaml`; quick SFT to produce LoRA adapter; `oumi_integration.py` to return top-N actions. -- **Day 4:** Cline templates for Terraform/Helm; `cline_integration.py` to render IaC and `cline pr create`; CodeRabbit webhook/Action for plan/tests. -- **Day 5:** Simulation runner applying PR to test env (localstack/kind); smoke + load tests; `compute_reward.py` to score before/after; persist results. -- **Day 6:** UI polish (Recommendations, PR Monitor, Before/After charts); manual approve/reject and what-if simulations. -- **Day 7:** Docs, demo script, final run-through, Vercel deploy. - -## 7) Example configs & code snippets -### 7.1 Kestra pipeline (pseudo YAML) +#### Tool: `propose_architecture` +```typescript +{ + serviceProfile: string; // JSON from ingest_repo + telemetrySummary?: string; // JSON from ingest_telemetry + cloudProvider?: string; // aws, gcp, azure (default: aws) +} +// Returns: ArchitecturePlan JSON ``` -id: collect-and-summarize -tasks: - - id: fetch-metrics - type: http - url: file://./examples/telemetry/metrics.json - - id: summarize - type: script - script: | - #!/usr/bin/env python3 - import json - metrics = json.load(open('examples/telemetry/metrics.json')) - summary = {} - for svc, vals in metrics.items(): - p95 = sorted(vals['latencies'])[int(0.95*len(vals['latencies']))] - p50 = sorted(vals['latencies'])[int(0.5*len(vals['latencies']))] - summary[svc] = {'p50': p50, 'p95': p95, 'error_rate': sum(vals['errors'])/len(vals['errors'])} - print(json.dumps(summary)) - - id: emit - type: http - url: http://localhost:8000/api/summaries + +#### Tool: `render_graph` +```typescript +{ + architecturePlan: string; // JSON from propose_architecture +} +// Returns: ReactFlow Graph JSON ``` -### 7.2 Oumi training config (simplified) +#### Tool: `generate_iac` +```typescript +{ + graph: string; // JSON from render_graph + cloudProvider?: string; // aws, gcp, azure + projectName?: string; // Resource naming prefix +} +// Returns: TerraformBundle with manifest ``` -model: - base: "base-llm-checkpoint" - adapter: "lora" -data: - sft_examples: "examples/sft_examples.jsonl" -rl: - method: "grpo" - reward: - cost_weight: 0.4 - latency_weight: 0.5 - reliability_weight: 0.1 -eval: - simulation_runner: "scripts/simulate_load.py" -training: - epochs: 3 - batch_size: 8 + +#### Tool: `validate_iac` +```typescript +{ + iacBundle: string; // Path to Terraform files +} +// Returns: ValidationResult JSON ``` -### 7.3 SFT example (examples/sft_examples.jsonl) +#### Tool: `create_pr` +```typescript +{ + iacBundle: string; // Path to Terraform files + repository: string; // owner/repo + targetFolder?: string; // Target folder in repo + labels?: string; // Comma-separated labels +} +// Returns: PRResult JSON ``` -{"input":"summary:{\"auth\":{\"p95\":420,\"p50\":120,\"error_rate\":0.01,\"cost\":40}}, repo_profile:{\"auth\":{\"cpu_est\":0.7}}","output":"action: add_hpa(service=auth,min=2,max=6); scale_instance(auth, from=t3.small,to=t3.medium)"} + +#### Tool: `validate_pr` +```typescript +{ + prResult: string; // JSON from create_pr + repository: string; // owner/repo +} +// Returns: ValidationStatus JSON ``` -### 7.4 Reward compute (scripts/compute_reward.py) -```python -def reward(before, after, weights=(0.4, 0.5, 0.1)): - cost_delta = (before['cost'] - after['cost']) / max(1, before['cost']) - latency_delta = (before['p95'] - after['p95']) / max(1, before['p95']) - reliability_delta = after.get('uptime', 1.0) - before.get('uptime', 1.0) - return weights[0]*cost_delta + weights[1]*latency_delta + weights[2]*reliability_delta +#### Tool: `evaluate` +```typescript +{ + deployResult: string; // JSON from validate_iac +} +// Returns: EvaluationResult JSON ``` -### 7.5 Cline example commands (pseudo) +### 4. Next.js UI + +**Purpose:** Visual dashboard for architecture management + +**Pages:** + +| Route | Component | Purpose | +|-------|-----------|---------| +| `/` | `page.jsx` | Landing page with features | +| `/dashboard` | `dashboard/page.jsx` | React Flow architecture editor | +| `/pipeline` | `pipeline/page.jsx` | Pipeline execution & monitoring | +| `/configure` | `configure/page.jsx` | Service configuration | + +**API Routes:** + +| Endpoint | Method | Purpose | +|----------|--------|---------| +| `/api/kestra/execute` | POST | Trigger Kestra pipeline | +| `/api/kestra/status/[id]` | GET | Get execution status | +| `/api/kestra/file` | GET | Fetch Kestra storage file | + +**Environment Variables:** + +| Variable | Default | Description | +|----------|---------|-------------| +| `KESTRA_API_URL` | `http://localhost:8080` | Kestra server URL | +| `KESTRA_TENANT` | `main` | Kestra tenant ID | +| `KESTRA_API_TOKEN` | - | Optional API token | +| `KESTRA_USERNAME` | - | Optional basic auth username | +| `KESTRA_PASSWORD` | - | Optional basic auth password | + +## Data Schemas + +### ServiceProfile + +```json +{ + "source": "https://github.com/owner/repo", + "services": { + "backend": { "type": "nodejs", "path": "/backend" }, + "frontend": { "type": "nodejs", "path": "/frontend" } + }, + "databases": ["postgres"], + "queues": ["redis"], + "service_count": 2, + "primary_language": "nodejs", + "has_infrastructure": false, + "analyzed_at": "2024-01-01T00:00:00Z" +} ``` -cline generate infra --service auth --provider aws --pattern ecs --output infra/auth -cline pr create --repo your-org/cloudgenesis --branch cloudgenesis/autoscale-auth --title "Auto: Add HPA for auth" --files infra/auth + +### TelemetrySummary + +```json +{ + "summary": { + "backend": { + "p50": 120, + "p95": 350, + "avg_latency": 180, + "error_rate": 0.02, + "cost": 45, + "cpu_usage": 0.65, + "memory_mb": 384 + } + }, + "collected_at": "2024-01-01T00:00:00Z", + "source": "mock|provided" +} ``` -### 7.6 CodeRabbit policy sample (pseudo-checklist) -- Terraform plan completes without error. -- No hardcoded secrets or credentials. -- Migration does not drop data without backup. -- Unit tests exist for service code changes. -- At least one smoke test included for infra change. -- Implement as GitHub Action that runs `terraform init && terraform plan`. - -## 8) CI/CD, testing, and quality gates -- PR gating: All Cline PRs must pass CodeRabbit checks before merge. -- Workflows: `ci/test.yml` (unit, lint, type checks), `ci/iac-check.yml` (terraform fmt/validate/plan or terratest), `ci/security.yml` (secret scan, dep audit). -- Test env: localstack for AWS, kind for k8s. -- Smoke/load tests: k6/vegeta under `tests/`. -- Automated rollback: failing smoke tests block merge or trigger rollback playbook. - -## 9) Best open-source practices & contributor workflow -- Apache-2.0 license; README with purpose and how-to-run. -- CONTRIBUTING with PR template, code style, testing requirements, labels. -- CODE_OF_CONDUCT (Contributor Covenant). -- Issue templates (bug/feature); branch strategy main/dev/feat-*; Conventional Commits. -- Changelog with semantic versioning or Unreleased section. -- Docs: `docs/architecture.md`, `docs/runlocally.md`, `docs/oumi.md`. -- Reproducible dev env (devcontainer or Docker compose). - -## 10) Security, privacy & safety checklist -- Secrets in GitHub Secrets/Vault; no repo secrets. -- Least privilege IAM; block open security groups and oversized instances. -- Human-in-loop: never auto-merge to main; CodeRabbit gate required. -- Telemetry anonymized; use test accounts/localstack for validation. -- Audit log every agent action and PR; rate-limit PR generation. -- Validate Oumi outputs with rule-based guardrails. -- Run dependency and secret scans in CI. - -## 11) Metrics, evaluation & judging criteria -- P95 latency reduction; cost reduction estimate. -- Time saved (analysis + implementation). -- Number of safe automated PRs and % passing CodeRabbit. -- False-positive/unsafe-change rate. -- Loop time (analysis β†’ PR β†’ test deploy). -- Include a one-slide metrics dashboard. - -## 12) Demo script (3–5 minutes) -1. Intro (15s): β€œCloudGenesis: autonomous cloud architect for dev teams.” -2. UI Overview (20s): Project Overview page with services/p95/cost. -3. Trigger Analysis (30s): Click β€œAnalyze” β†’ Kestra summarizer β†’ `summary.json`. -4. Recommendation (30s): Oumi suggests β€œAdd HPA to auth; change instance type.” Show estimated impact. -5. Create PR (20s): Click β€œApply” β†’ Cline PR β†’ show GitHub, CodeRabbit checks. -6. Test Deploy (45s): Merge to test branch β†’ deploy to localstack/kind β†’ smoke/load tests; show before/after charts. -7. Wrap (20s): Summarize improvements; emphasize human-in-loop safety. - -## 13) Hardest technical challenges + mitigations -- Multi-objective optimization: start with weighted latency/cost; expose weights in UI. -- Safety of IaC: rule-based validators, CodeRabbit gating, terraform plan in test env. -- Noisy telemetry: synthetic load + sliding windows; SFT on synthetic examples. -- Runtime constraints: small SFT/LoRA adapters; defer RL unless time permits. - -## 14) Stretch goals & future roadmap -- Multi-cloud planner (AWS/GCP/Azure), migration suggestions. -- Multi-agent specialization (DB/network/infra). -- Live RL with canaries and auto-rollback. -- Auto-generated runbooks and postmortems. -- Billing optimization (reserved instances, savings plans). -- Marketplace for reusable IaC patterns and cost rules. - -## 15) Quick start checklist -- GitHub repo + Actions enabled. -- Add Apache-2.0 LICENSE, README, CONTRIBUTING, CODE_OF_CONDUCT. -- Sample services `auth` and `payments` with Dockerfiles. -- Implement `repo_analyzer/scan.py` β†’ `service_profile.json`. -- Add telemetry in `examples/telemetry/metrics.json`. -- Add Kestra pipelines to POST summaries to orchestrator. -- Create `examples/sft_examples.jsonl` (50 SFT samples). -- Prepare `oumi_train.yaml` and run quick SFT. -- Implement `oumi_integration.py` to call model and return actions. -- Add Cline templates and `cline_integration.py` to create PRs. -- GitHub Action for terraform plan/tests (CodeRabbit simulated if needed). -- Deploy UI to Vercel; prepare demo script; run E2E once. +### ArchitecturePlan + +```json +{ + "architecture": { + "pattern": "microservices_ecs", + "components": ["api_gateway", "ecs_cluster", "alb", "rds"], + "topology": "2 services with microservices_ecs pattern on aws", + "scaling_strategy": "horizontal_autoscaling", + "estimated_cost_tier": "medium", + "rationale": "Selected microservices_ecs based on 2 services" + }, + "inputs": { + "service_count": 2, + "cloud_provider": "aws" + }, + "source": "oumi|heuristic" +} +``` + +### ReactFlow Graph + +```json +{ + "nodes": [ + { + "id": "api_gateway", + "type": "infrastructureNode", + "data": { + "label": "Api Gateway", + "type": "api_gateway", + "icon": "globe", + "category": "network", + "scaling": false + }, + "position": { "x": 0, "y": 180 }, + "style": { + "background": "#FF9800", + "borderRadius": "8px" + } + } + ], + "edges": [ + { + "id": "cdn-api_gateway", + "source": "cdn", + "target": "api_gateway", + "type": "smoothstep", + "animated": true + } + ] +} +``` + +### IaC Manifest + +```json +{ + "files": ["main.tf", "variables.tf", "outputs.tf"], + "cloud_provider": "aws", + "project_name": "infoundry", + "components": ["api_gateway", "ecs_cluster", "rds"], + "generated_at": "2024-01-01T00:00:00Z" +} +``` + +## Infrastructure Components Mapping + +### AWS Components + +| Component | Terraform Resource | Description | +|-----------|-------------------|-------------| +| `api_gateway` | `aws_apigatewayv2_api` | HTTP API Gateway | +| `ecs_cluster` | `aws_ecs_cluster` | ECS Fargate Cluster | +| `eks_cluster` | `aws_eks_cluster` | Kubernetes Cluster | +| `lambda_functions` | `aws_lambda_function` | Serverless Functions | +| `alb` | `aws_lb` | Application Load Balancer | +| `rds` | `aws_db_instance` | RDS PostgreSQL/MySQL | +| `dynamodb` | `aws_dynamodb_table` | NoSQL Database | +| `elasticache` | `aws_elasticache_cluster` | Redis Cache | +| `sqs` | `aws_sqs_queue` | Message Queue | +| `sns` | `aws_sns_topic` | Pub/Sub Topic | +| `msk` | `aws_msk_cluster` | Managed Kafka | +| `cdn` | `aws_cloudfront_distribution` | CDN | +| `s3` | `aws_s3_bucket` | Object Storage | + +## Decision Matrix + +### Architecture Pattern Selection + +| Criteria | serverless | microservices_ecs | kubernetes | event_driven | +|----------|------------|-------------------|------------|--------------| +| Service Count | 1-2 | 3-4 | 5+ | Any | +| Traffic Pattern | Low/Burst | Moderate | High | Event-based | +| Cost Sensitivity | High | Medium | Low | Medium | +| Latency Needs | Variable | Low | Very Low | Async OK | +| Team Size | Small | Medium | Large | Medium | + +### Scaling Strategy Selection + +| Strategy | Use Case | Components | +|----------|----------|------------| +| `serverless_autoscaling` | Lambda functions | No configuration needed | +| `vertical_scaling` | Simple apps, DBs | Resize instances | +| `horizontal_autoscaling` | Stateless services | ASG, ECS Service scaling | +| `kubernetes_hpa` | K8s workloads | Horizontal Pod Autoscaler | + +## Testing Strategy + +### Unit Tests + +```bash +# Python tests (pytest) +pytest tests/ -v + +# MCP server tests (Node.js) +node tests/test_mcp_server.mjs + +# Oumi server tests +pytest tests/test_oumi_serve.py -v +``` + +### Integration Tests + +```bash +# Kestra pipeline tests +node tests/test_kestra.js +``` + +### Manual Testing + +1. Start all services (see `runlocally.md`) +2. Open UI at http://localhost:3000 +3. Navigate to `/pipeline` +4. Enter a GitHub repository URL +5. Run the pipeline and monitor progress + +## Deployment Options + +### Local Development +- Docker Compose for all services +- See `runlocally.md` for details + +### Cloud Deployment + +**Vercel (UI):** +```bash +cd ui +vercel deploy +``` + +**Docker (Services):** +```dockerfile +# Example Oumi Dockerfile +FROM python:3.11-slim +WORKDIR /app +COPY requirements.txt . +RUN pip install -r requirements.txt +COPY oumi/ . +CMD ["uvicorn", "serve:app", "--host", "0.0.0.0", "--port", "8000"] +``` + +**Kubernetes:** +- Deploy Kestra via Helm chart +- Deploy Oumi server as Deployment + Service +- Deploy UI as Deployment + Ingress + +## Future Enhancements + +See [ROADMAP.md](../ROADMAP.md) for planned features: +- Multi-cloud support (GCP, Azure) +- Enhanced authentication +- Automated compliance auditing +- CI/CD platform integrations +- Advanced cost estimation +- AI-driven architecture optimization +- Collaborative real-time editing diff --git a/docs/architecture.md b/docs/architecture.md index bf24244..9b7b41d 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -1,9 +1,259 @@ -# Architecture Notes (MVP) +# InFoundry Architecture -- Orchestrator (FastAPI) exposes endpoints for summaries, recommendations, and PR triggers. -- Kestra pipelines ingest telemetry and produce `summary.json`. -- Oumi integration ranks actions from summaries. -- Cline integration renders IaC templates and opens PRs. -- CodeRabbit/GitHub Actions gate merges via terraform plan + tests. -- Simulation runner (localstack/kind) validates changes before merge; metrics feed back into rewards. +This document provides a comprehensive overview of InFoundry's system architecture, including all components, their interactions, and data flows. +## System Overview + +InFoundry is a self-adaptive Cloud Architect + SRE agent that: +1. Inspects codebases and telemetry +2. Proposes deployable IaC/CI changes +3. Runs safe test deployments +4. Iteratively optimizes cost, latency, and reliability with human-in-the-loop approvals + +``` +β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” +β”‚ InFoundry Architecture β”‚ +β”œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€ +β”‚ β”‚ +β”‚ β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”‚ +β”‚ β”‚ Next.js │────▢│ Kestra Pipeline │────▢│ Oumi AI Model β”‚ β”‚ +β”‚ β”‚ UI (3000) │◀────│ Orchestrator │◀────│ Server (8000) β”‚ β”‚ +β”‚ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β”‚ +β”‚ β”‚ β”‚ β”‚ β”‚ +β”‚ β”‚ β”‚ β”‚ β”‚ +β”‚ β–Ό β–Ό β–Ό β”‚ +β”‚ β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”‚ +β”‚ β”‚ React Flow β”‚ β”‚ MCP Server β”‚ β”‚ Trained LoRA Model β”‚ β”‚ +β”‚ β”‚ Diagrams β”‚ β”‚ (Cline/Claude) β”‚ β”‚ Qwen2.5-1.5B-Instruct β”‚ β”‚ +β”‚ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β”‚ +β”‚ β”‚ +β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ +``` + +## Core Components + +### 1. Next.js UI (`/ui`) + +The user-facing dashboard built with Next.js 15. + +**Technology Stack:** +- Next.js 15 with App Router +- React 18 +- React Flow (@xyflow/react) for architecture visualization +- Lucide React for icons +- CSS Modules for styling + +**Key Pages:** +| Route | Purpose | +|-------|---------| +| `/` | Landing page with feature overview | +| `/dashboard` | Visual architecture editor with React Flow | +| `/pipeline` | Kestra pipeline runner and monitor | +| `/configure` | Service profile configuration | + +**Key Components:** +- `PipelineForm` - Collects pipeline inputs (repo URL, cloud provider, etc.) +- `StepProgressBar` - Real-time pipeline step tracking +- `StepOutputCard` - Displays step outputs and artifacts +- `ServiceConfigGenerator` - Interactive service configuration + +### 2. Kestra Pipeline Orchestrator (`/orchestrator`) + +Kestra orchestrates the complete infrastructure lifecycle with 9 sequential steps. + +**Pipeline Flow:** +``` +β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” +β”‚ 01. Ingest │──▢│ 02. Ingest │──▢│ 03. Propose │──▢│ 04. Render β”‚ +β”‚ Repo β”‚ β”‚ Telemetry β”‚ β”‚Architecture β”‚ β”‚ Graph β”‚ +β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ + β”‚ +β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”‚ +β”‚09. Evaluate │◀──│ 08. Validate│◀──│ 07. Create β”‚β—€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ +β”‚ β”‚ β”‚ PR β”‚ β”‚ PR β”‚ β”‚ +β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β”‚ + β”‚ + β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”‚ + β”‚ 06. Validate│◀──│05. Generate β”‚β—€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ + β”‚ IaC β”‚ β”‚ IaC β”‚ + β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ +``` + +**Pipeline Steps:** + +| Step | Pipeline File | Description | Outputs | +|------|---------------|-------------|---------| +| 1 | `01-ingest-repo.yaml` | Analyzes repository for services, DBs, queues | `service_profile.json` | +| 2 | `02-ingest-telemetry.yaml` | Collects service telemetry metrics | `telemetry_summary.json` | +| 3 | `03-propose-architecture.yaml` | AI-powered architecture proposal | `architecture_plan.json` | +| 4 | `04-render-graph.yaml` | Converts architecture to React Flow graph | `graph.json` | +| 5 | `05-generate-iac.yaml` | Generates Terraform using AI Agent | `iac_bundle.zip` | +| 6 | `06-validate-iac.yaml` | Validates Terraform (fmt, init, validate) | `deploy_result.json` | +| 7 | `07-create-pr.yaml` | Creates GitHub PR with IaC files | `pr_result.json` | +| 8 | `08-validate-pr.yaml` | Monitors PR status and CI checks | `validation_result.json` | +| 9 | `09-evaluate.yaml` | Computes reward score for optimization | `evaluation_result.json` | + +**AI Agent Integration:** +The `05-generate-iac.yaml` pipeline uses Kestra's built-in AI Agent for: +- **Data Summarization**: Analyzes complex graph data and produces technical summaries +- **Autonomous Decision Making**: Makes IaC configuration decisions (encryption, instance tiers, auto-scaling) + +### 3. Oumi AI Model (`/oumi`) + +The "brain" of InFoundry - a fine-tuned LLM for cloud architecture recommendations. + +**Model Details:** +- Base Model: `Qwen/Qwen2.5-1.5B-Instruct` +- Training: LoRA (Low-Rank Adaptation) fine-tuning +- Training Data: 500 architecture examples +- Published: [crypticsayan/infoundry-architect](https://huggingface.co/crypticsayan/infoundry-architect) + +**Key Files:** +| File | Purpose | +|------|---------| +| `serve.py` | FastAPI server with OpenAI-compatible endpoint | +| `train_sft.py` | SFT training script with LoRA | +| `run_inference.py` | Test the trained model | +| `generate_training_data.py` | Rule-based training data generator | + +**Model Output Schema:** +```json +{ + "architecture": { + "pattern": "serverless|microservices_ecs|kubernetes|event_driven", + "components": ["api_gateway", "lambda", "rds", "..."], + "topology": "N services with PATTERN on CLOUD", + "scaling_strategy": "horizontal_autoscaling|serverless_autoscaling", + "estimated_cost_tier": "low|medium|high", + "rationale": "Explanation of architecture choice" + }, + "inputs": { + "service_count": 3, + "cloud_provider": "aws" + }, + "source": "ai_recommendation" +} +``` + +**Inference Hierarchy:** +1. **Oumi Model** (trained model) - Primary +2. **Ollama** (local LLM) - Fallback +3. **Heuristics** - Final fallback + +### 4. MCP Server (`/infoundry-mcp-server`) + +Model Context Protocol server for Cline CLI integration. + +**Technology:** +- TypeScript with ES modules +- `@modelcontextprotocol/sdk` for MCP protocol +- `zod` for input validation + +**Exposed Tools (9 steps mirroring Kestra):** + +| Tool | Description | +|------|-------------| +| `ingest_repo` | Analyze repository (local or GitHub URL) | +| `ingest_telemetry` | Collect service telemetry metrics | +| `propose_architecture` | AI architecture proposal using Oumi | +| `render_graph` | Convert architecture to React Flow graph | +| `generate_iac` | Generate Terraform from graph | +| `validate_iac` | Validate Terraform code | +| `create_pr` | Create GitHub PR with IaC files | +| `validate_pr` | Check PR status and reviews | +| `evaluate` | AI evaluation with recommendations | + +## Data Flow + +### End-to-End Pipeline Flow + +``` +User Input Processing Output +───────────────────────────────────────────────────────────────────── + +GitHub Repo URL ──▢ Clone & Analyze ──▢ service_profile.json + β”‚ β”‚ + β–Ό β–Ό +Service Names ──▢ Collect Metrics ──▢ telemetry_summary.json + β”‚ β”‚ + β–Ό β–Ό +Service Profile ──▢ Oumi AI Model ──▢ architecture_plan.json ++ Telemetry β”‚ + β”‚ β–Ό + β”‚ Convert to React Flow ──▢ graph.json + β”‚ β”‚ + β”‚ β–Ό + β”‚ AI Agent + Heuristics ──▢ iac_bundle.zip + β”‚ β”‚ + β”‚ β–Ό + β”‚ Terraform Validation ──▢ deploy_result.json + β”‚ β”‚ + β”‚ β–Ό + β”‚ Create GitHub PR ──▢ pr_result.json + β”‚ β”‚ + β”‚ β–Ό + β”‚ Monitor CI Checks ──▢ validation_result.json + β”‚ β”‚ + β–Ό β–Ό + Evaluate Results ──▢ evaluation_result.json +``` + +### Architecture Component Categories + +InFoundry classifies infrastructure components into categories: + +| Category | AWS Components | +|----------|---------------| +| **Network** | CDN (CloudFront), API Gateway, ALB, VPC | +| **Compute** | ECS Cluster, EKS Cluster, Lambda Functions | +| **Database** | RDS, DynamoDB, ElastiCache | +| **Messaging** | SQS, SNS, MSK (Kafka), EventBridge | +| **Storage** | S3, EFS | + +### Architecture Patterns + +| Pattern | Use Case | Components | +|---------|----------|------------| +| `serverless` | 1-2 services, low traffic | API Gateway, Lambda, DynamoDB | +| `microservices_ecs` | 3-4 services, moderate traffic | ECS, ALB, RDS | +| `kubernetes` | 5+ services, high traffic | EKS, ALB, RDS, ElastiCache | +| `event_driven` | Event processing, async | MSK/SQS, Lambda, EventBridge | + +## Integration Points + +### External Services + +| Service | Purpose | Configuration | +|---------|---------|---------------| +| **GitHub** | Repository analysis, PR creation | `GITHUB_TOKEN` | +| **Kestra** | Pipeline orchestration | `KESTRA_API_URL`, `KESTRA_API_TOKEN` | +| **Ollama** | Local LLM fallback | `OLLAMA_URL` (default: localhost:11434) | +| **AWS** | Cloud deployment | `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` | + +### API Endpoints + +**Oumi Server (port 8000):** +- `POST /v1/chat/completions` - OpenAI-compatible chat endpoint +- `GET /health` - Health check + +**Kestra (port 8080):** +- `POST /api/v1/executions` - Trigger pipeline execution +- `GET /api/v1/executions/{id}` - Get execution status + +**Next.js UI (port 3000):** +- `/api/kestra/execute` - Proxy to Kestra execution +- `/api/kestra/status/{id}` - Proxy to Kestra status +- `/api/kestra/file` - Fetch Kestra storage files + +## Security Considerations + +1. **Path Validation**: MCP server validates paths to prevent command injection +2. **Environment Secrets**: Sensitive values stored as environment variables +3. **Temporary Files**: Cloned repos are cleaned up after analysis +4. **API Authentication**: Kestra supports token and basic auth + +## Scalability + +- **Horizontal Scaling**: Kestra workers can be scaled independently +- **Model Serving**: Oumi server can run multiple replicas behind a load balancer +- **UI Scaling**: Next.js can be deployed on Vercel or Kubernetes with auto-scaling diff --git a/docs/runlocally.md b/docs/runlocally.md index 0795774..7eb19c6 100644 --- a/docs/runlocally.md +++ b/docs/runlocally.md @@ -1,31 +1,546 @@ -# Run locally (scaffold) +# Running InFoundry Locally -1) Repo analyzer +This guide walks you through setting up and running InFoundry on your local machine for development and testing. + +## Prerequisites + +Before you begin, ensure you have the following installed: + +| Requirement | Minimum Version | Purpose | +|-------------|-----------------|---------| +| Python | 3.11+ | Oumi AI server, tests | +| Node.js | 18+ | UI, MCP server | +| npm | 9+ | Package management | +| Git | 2.x | Repository cloning | +| Docker | 20+ | Kestra, optional services | +| Docker Compose | 2.x | Multi-container setup | + +### Optional Dependencies + +| Tool | Purpose | +|------|---------| +| Ollama | Local LLM fallback | +| kind | Local Kubernetes cluster | +| LocalStack | AWS emulation | +| Terraform | IaC validation | + +## Quick Start + +### 1. Clone the Repository + +```bash +git clone https://github.com/crypticsaiyan/infoundry.git +cd infoundry +``` + +### 2. Install Dependencies + +```bash +# Python dependencies +pip install -r requirements.txt + +# UI dependencies +cd ui && npm install && cd .. + +# MCP server dependencies +cd infoundry-mcp-server && npm install && npm run build && cd .. +``` + +### 3. Start All Services + +Open three terminal windows/tabs: + +**Terminal 1 - Oumi AI Server:** +```bash +cd oumi +python serve.py +# Server starts at http://localhost:8000 +``` + +**Terminal 2 - Kestra (Docker):** +```bash +docker run --pull=always --rm -it -p 8080:8080 \ + --user=root \ + -v /var/run/docker.sock:/var/run/docker.sock \ + -v /tmp:/tmp \ + kestra/kestra:latest server local +# Kestra UI at http://localhost:8080 +``` + +**Terminal 3 - Next.js UI:** +```bash +cd ui +cp .env.example .env.local +# Edit .env.local if needed +npm run dev +# UI starts at http://localhost:3000 +``` + +## Detailed Setup + +### Python Environment (Recommended) + +```bash +# Create virtual environment +python -m venv venv + +# Activate (Linux/macOS) +source venv/bin/activate + +# Activate (Fish shell) +source venv/bin/activate.fish + +# Activate (Windows) +.\venv\Scripts\activate + +# Install dependencies +pip install -r requirements.txt +``` + +### Oumi Model Setup + +The Oumi model provides AI-powered architecture recommendations. + +#### Option A: Use Pre-trained Model (Recommended) + +```bash +cd oumi + +# Install Git LFS if not already installed +git lfs install + +# Clone the trained model from Hugging Face +git clone https://huggingface.co/crypticsayan/infoundry-architect trained_model +``` + +#### Option B: Train Your Own Model + +```bash +cd oumi + +# Generate training data +python generate_training_data.py --count 500 + +# Train the model (requires GPU) +python train_sft.py +``` + +#### Option C: Use with Google Colab + +1. Open `oumi/InFoundry_Cloud_Training.ipynb` in Google Colab +2. Select a T4 GPU runtime +3. Run all cells to train the model +4. Download the trained model + +### Starting the Oumi Server + +```bash +cd oumi +python serve.py ``` -python orchestrator/repo_analyzer/scan.py + +**Environment Variables:** + +| Variable | Default | Description | +|----------|---------|-------------| +| `USE_OUMI` | `true` | Use trained Oumi model | +| `USE_OLLAMA` | `false` | Fallback to Ollama | +| `OLLAMA_URL` | `http://localhost:11434` | Ollama server URL | + +**Test the server:** +```bash +curl -X POST http://localhost:8000/v1/chat/completions \ + -H "Content-Type: application/json" \ + -d '{ + "model": "oumi", + "messages": [{"role": "user", "content": "Recommend architecture for 3 nodejs services"}] + }' +``` + +### Kestra Setup + +#### Option A: Docker (Recommended for Development) + +```bash +# Single container with local storage +docker run --pull=always --rm -it -p 8080:8080 \ + --user=root \ + -v /var/run/docker.sock:/var/run/docker.sock \ + -v /tmp:/tmp \ + kestra/kestra:latest server local +``` + +#### Option B: Docker Compose (Production-like) + +Create `docker-compose.yml`: + +```yaml +version: '3.8' +services: + kestra: + image: kestra/kestra:latest + ports: + - "8080:8080" + volumes: + - /var/run/docker.sock:/var/run/docker.sock + - /tmp:/tmp + - kestra-data:/app/storage + environment: + - KESTRA_CONFIGURATION_STRING=| + datasources: + postgres: + url: jdbc:postgresql://postgres:5432/kestra + driverClassName: org.postgresql.Driver + username: kestra + password: kestra + depends_on: + - postgres + + postgres: + image: postgres:15 + environment: + POSTGRES_USER: kestra + POSTGRES_PASSWORD: kestra + POSTGRES_DB: kestra + volumes: + - postgres-data:/var/lib/postgresql/data + +volumes: + kestra-data: + postgres-data: ``` -2) Telemetry summary (mocked) +Run: +```bash +docker-compose up -d ``` -python orchestrator/kestra_pipelines/collect-and-summarize.yaml + +#### Deploy Pipelines to Kestra + +```bash +cd orchestrator/kestra_pipelines + +# Upload all pipeline files +for f in *.yaml; do + curl -X POST http://localhost:8080/api/v1/flows \ + -H "Content-Type: application/x-yaml" \ + --data-binary @"$f" +done ``` -Use with Kestra or run the script section manually. -3) Oumi stub +**Fish shell version:** +```fish +cd orchestrator/kestra_pipelines + +for f in *.yaml + curl -X POST http://localhost:8080/api/v1/flows \ + -H "Content-Type: application/x-yaml" \ + --data-binary @$f +end ``` -python orchestrator/oumi_integration.py + +#### Configure Kestra Secrets + +Set secrets in the Kestra UI (http://localhost:8080) or via API: + +```bash +# GitHub Token (for PR creation) +curl -X PUT http://localhost:8080/api/v1/namespaces/infoundry/secrets/GITHUB_TOKEN \ + -H "Content-Type: text/plain" \ + -d "ghp_your_github_token" + +# AWS Credentials (optional, for deployment) +curl -X PUT http://localhost:8080/api/v1/namespaces/infoundry/secrets/AWS_ACCESS_KEY_ID \ + -H "Content-Type: text/plain" \ + -d "your_access_key" + +curl -X PUT http://localhost:8080/api/v1/namespaces/infoundry/secrets/AWS_SECRET_ACCESS_KEY \ + -H "Content-Type: text/plain" \ + -d "your_secret_key" ``` -4) Generate IaC stub +### Next.js UI Setup + +```bash +cd ui + +# Copy environment template +cp .env.example .env.local ``` -python -c "from orchestrator.cline_integration import propose_change; propose_change('auth')" + +Edit `.env.local`: +```env +KESTRA_API_URL=http://localhost:8080 +KESTRA_TENANT=main +# Optional authentication +# KESTRA_API_TOKEN=your_token +# KESTRA_USERNAME=admin +# KESTRA_PASSWORD=admin ``` -5) Simulation +Start development server: +```bash +npm run dev ``` -python scripts/simulate_load.py -python scripts/compute_reward.py + +Access the UI at http://localhost:3000 + +### MCP Server Setup (For Cline Integration) + +```bash +cd infoundry-mcp-server + +# Install dependencies +npm install + +# Build TypeScript +npm run build ``` -These steps are placeholders; replace with real orchestrator endpoints and CI/CD when ready. +Configure Cline to use the MCP server. Add to `~/.config/cline/mcp.json`: + +```json +{ + "mcpServers": { + "infoundry-architect": { + "command": "node", + "args": ["/path/to/infoundry/infoundry-mcp-server/dist/index.js"], + "env": { + "GITHUB_TOKEN": "ghp_your_github_token" + } + } + } +} +``` + +## Optional: Ollama Setup + +Ollama provides a local LLM fallback when the Oumi model is unavailable. + +### Install Ollama + +```bash +# Linux +curl -fsSL https://ollama.ai/install.sh | sh + +# macOS +brew install ollama + +# Windows - Download from https://ollama.ai +``` + +### Start Ollama and Pull Model + +```bash +# Start Ollama server +ollama serve + +# In another terminal, pull a model +ollama pull codellama +# or +ollama pull qwen2.5:7b +``` + +### Configure Oumi to Use Ollama + +Set environment variable before starting serve.py: + +```bash +USE_OLLAMA=true python serve.py +``` + +## Running Tests + +### Python Tests + +```bash +# Install test dependencies +pip install pytest httpx + +# Run all tests +pytest tests/ -v + +# Run specific tests +pytest tests/test_oumi_serve.py -v +pytest tests/test_generate_training_data.py -v +``` + +### MCP Server Tests + +```bash +# Ensure Oumi server is running first +cd oumi && python serve.py & + +# Run tests +node tests/test_mcp_server.mjs +``` + +### Kestra Pipeline Tests + +```bash +# Ensure Kestra is running +node tests/test_kestra.js +``` + +## Full Stack Development Workflow + +### 1. Start All Services + +```bash +# Terminal 1: Start Oumi server +cd oumi && python serve.py + +# Terminal 2: Start Kestra +docker run --pull=always --rm -it -p 8080:8080 \ + --user=root \ + -v /var/run/docker.sock:/var/run/docker.sock \ + -v /tmp:/tmp \ + kestra/kestra:latest server local + +# Terminal 3: Start UI +cd ui && npm run dev +``` + +### 2. Upload Kestra Pipelines + +```bash +cd orchestrator/kestra_pipelines +for f in *.yaml; do + curl -X POST http://localhost:8080/api/v1/flows \ + -H "Content-Type: application/x-yaml" \ + --data-binary @"$f" +done +``` + +### 3. Access the Application + +- **UI Dashboard:** http://localhost:3000 +- **Kestra UI:** http://localhost:8080 +- **Oumi API:** http://localhost:8000 + +### 4. Test the Pipeline + +1. Open http://localhost:3000/pipeline +2. Enter a GitHub repository URL (e.g., `https://github.com/crypticsaiyan/infotest`) +3. Configure options (cloud provider, project name, etc.) +4. Click "Run Pipeline" +5. Monitor progress in real-time + +### 5. Test via API + +```bash +# Trigger end-to-end pipeline +curl -X POST http://localhost:8080/api/v1/executions \ + -H "Content-Type: application/json" \ + -d '{ + "namespace": "infoundry", + "flowId": "end-to-end", + "inputs": { + "repo_url": "https://github.com/crypticsaiyan/infotest", + "branch": "main", + "repository": "crypticsaiyan/infotest", + "cloud_provider": "aws", + "project_name": "infoundry-demo", + "skip_pr": true + } + }' +``` + +## Troubleshooting + +### Oumi Server Won't Start + +**Problem:** `ModuleNotFoundError: No module named 'oumi'` + +**Solution:** +```bash +pip install oumi[gpu] +# or without GPU +pip install oumi +``` + +### Kestra Pipeline Fails + +**Problem:** AI tasks fail with connection refused + +**Solution:** The Kestra container can't reach Ollama on localhost. Use Docker's host gateway: +```bash +# In pipeline YAML, use: +baseUrl: "http://172.17.0.1:11434/v1" # Docker gateway to host +``` + +### UI Can't Connect to Kestra + +**Problem:** CORS errors or connection refused + +**Solution:** Check `.env.local` has correct `KESTRA_API_URL` and Kestra is running. + +### MCP Server Not Found by Cline + +**Problem:** Cline can't find the InFoundry MCP server + +**Solution:** +1. Verify the path in `mcp.json` is absolute +2. Ensure `npm run build` was run +3. Check `dist/index.js` exists + +### Model Inference is Slow + +**Problem:** Architecture proposals take too long + +**Solution:** +1. Use Ollama with a smaller model: `ollama pull qwen2.5:7b` +2. Enable GPU acceleration if available +3. The heuristic fallback is always fast + +### Out of Memory During Training + +**Problem:** Training fails with OOM error + +**Solution:** +1. Use Google Colab with T4 GPU (free tier) +2. Reduce batch size in `train_sft.py` +3. Use gradient checkpointing + +## Port Summary + +| Service | Port | URL | +|---------|------|-----| +| Next.js UI | 3000 | http://localhost:3000 | +| Oumi Server | 8000 | http://localhost:8000 | +| Kestra | 8080 | http://localhost:8080 | +| Ollama | 11434 | http://localhost:11434 | + +## Environment Variables Summary + +### Oumi Server +| Variable | Default | Description | +|----------|---------|-------------| +| `USE_OUMI` | `true` | Use trained Oumi model | +| `USE_OLLAMA` | `false` | Use Ollama as fallback | +| `OLLAMA_URL` | `http://localhost:11434` | Ollama server URL | + +### Next.js UI +| Variable | Default | Description | +|----------|---------|-------------| +| `KESTRA_API_URL` | `http://localhost:8080` | Kestra server URL | +| `KESTRA_TENANT` | `main` | Kestra tenant ID | +| `KESTRA_API_TOKEN` | - | Optional API token | +| `KESTRA_USERNAME` | - | Optional basic auth | +| `KESTRA_PASSWORD` | - | Optional basic auth | + +### MCP Server +| Variable | Default | Description | +|----------|---------|-------------| +| `GITHUB_TOKEN` | - | GitHub PAT for PR creation | +| `KESTRA_URL` | `http://localhost:8080` | Kestra server URL | + +## Next Steps + +After successfully running locally: +1. **Explore the UI:** Navigate to `/dashboard` to see the architecture editor +2. **Run a Pipeline:** Go to `/pipeline` and analyze a real repository +3. **Test MCP Tools:** Use Cline to interact with InFoundry tools +4. **Customize Pipelines:** Modify Kestra YAML files for your needs +5. **Train Custom Models:** Generate domain-specific training data diff --git a/examples/sample_architecture_plan.json b/examples/sample_architecture_plan.json new file mode 100644 index 0000000..4544307 --- /dev/null +++ b/examples/sample_architecture_plan.json @@ -0,0 +1,15 @@ +{ + "architecture": { + "pattern": "microservices_ecs", + "components": ["api_gateway", "ecs_cluster", "alb", "rds", "elasticache", "hpa", "cdn"], + "topology": "2 services with microservices_ecs pattern on aws", + "scaling_strategy": "horizontal_autoscaling", + "estimated_cost_tier": "medium", + "rationale": "Selected microservices_ecs based on 2 services with high latency" + }, + "inputs": { + "service_count": 2, + "cloud_provider": "aws" + }, + "source": "heuristic" +} diff --git a/examples/sample_deploy_result.json b/examples/sample_deploy_result.json new file mode 100644 index 0000000..019941c --- /dev/null +++ b/examples/sample_deploy_result.json @@ -0,0 +1,20 @@ +{ + "environment": "localstack", + "terraform_action": "apply", + "deploy_status": "success", + "deploy_output": "Apply complete! Resources: 5 added, 0 changed, 0 destroyed.", + "smoke_tests": { + "passed": 3, + "failed": 0, + "tests": [ + {"name": "health_check", "passed": true}, + {"name": "s3_list", "passed": true}, + {"name": "dynamodb_list", "passed": true} + ] + }, + "load_tests": null, + "cleanup_status": "completed", + "started_at": "2025-12-11T08:00:00.000000", + "completed_at": "2025-12-11T08:05:00.000000", + "success": true +} diff --git a/examples/sample_graph.json b/examples/sample_graph.json new file mode 100644 index 0000000..91a0dfc --- /dev/null +++ b/examples/sample_graph.json @@ -0,0 +1,170 @@ +{ + "nodes": [ + { + "id": "cdn", + "type": "infrastructureNode", + "data": { + "label": "Cdn", + "type": "cdn", + "icon": "cloud", + "category": "network", + "scaling": false + }, + "position": { "x": 125, "y": 0 }, + "style": { + "background": "#00BCD4", + "borderRadius": "8px", + "border": "2px solid rgba(255,255,255,0.2)" + } + }, + { + "id": "api_gateway", + "type": "infrastructureNode", + "data": { + "label": "Api Gateway", + "type": "api_gateway", + "icon": "globe", + "category": "network", + "scaling": false + }, + "position": { "x": 0, "y": 180 }, + "style": { + "background": "#FF9800", + "borderRadius": "8px", + "border": "2px solid rgba(255,255,255,0.2)" + } + }, + { + "id": "alb", + "type": "infrastructureNode", + "data": { + "label": "Alb", + "type": "alb", + "icon": "share-2", + "category": "network", + "scaling": false + }, + "position": { "x": 250, "y": 180 }, + "style": { + "background": "#2196F3", + "borderRadius": "8px", + "border": "2px solid rgba(255,255,255,0.2)" + } + }, + { + "id": "ecs_cluster", + "type": "infrastructureNode", + "data": { + "label": "Ecs Cluster", + "type": "ecs_cluster", + "icon": "box", + "category": "compute", + "scaling": true + }, + "position": { "x": 125, "y": 360 }, + "style": { + "background": "#4CAF50", + "borderRadius": "8px", + "border": "2px solid rgba(255,255,255,0.2)" + } + }, + { + "id": "rds", + "type": "infrastructureNode", + "data": { + "label": "Rds", + "type": "rds", + "icon": "database", + "category": "database", + "scaling": false + }, + "position": { "x": 0, "y": 540 }, + "style": { + "background": "#3F51B5", + "borderRadius": "8px", + "border": "2px solid rgba(255,255,255,0.2)" + } + }, + { + "id": "elasticache", + "type": "infrastructureNode", + "data": { + "label": "Elasticache", + "type": "elasticache", + "icon": "cpu", + "category": "cache", + "scaling": false + }, + "position": { "x": 250, "y": 540 }, + "style": { + "background": "#E91E63", + "borderRadius": "8px", + "border": "2px solid rgba(255,255,255,0.2)" + } + } + ], + "edges": [ + { + "id": "e0", + "source": "cdn", + "target": "alb", + "type": "smoothstep", + "animated": true, + "style": { "stroke": "#00BCD4" } + }, + { + "id": "e1", + "source": "cdn", + "target": "api_gateway", + "type": "smoothstep", + "animated": true, + "style": { "stroke": "#00BCD4" } + }, + { + "id": "e2", + "source": "api_gateway", + "target": "ecs_cluster", + "type": "smoothstep", + "animated": true, + "style": { "stroke": "#FF9800" } + }, + { + "id": "e3", + "source": "alb", + "target": "ecs_cluster", + "type": "smoothstep", + "animated": true, + "style": { "stroke": "#2196F3" } + }, + { + "id": "e4", + "source": "ecs_cluster", + "target": "rds", + "type": "smoothstep", + "animated": false, + "style": { "stroke": "#4CAF50" } + }, + { + "id": "e5", + "source": "ecs_cluster", + "target": "elasticache", + "type": "smoothstep", + "animated": false, + "style": { "stroke": "#4CAF50" } + } + ], + "metadata": { + "pattern": "microservices_ecs", + "topology": "3 services with microservices_ecs on aws", + "scaling_strategy": "horizontal_autoscaling", + "rationale": "Selected microservices_ecs for 3 services with high latency indicators", + "estimated_cost_tier": "medium", + "component_count": 6, + "edge_count": 6, + "source": "oumi", + "cloud_provider": "aws", + "service_count": 3, + "primary_language": "python", + "generated_at": "2025-12-13T07:30:00.000000" + } +} diff --git a/examples/sample_pr_result.json b/examples/sample_pr_result.json new file mode 100644 index 0000000..80c0992 --- /dev/null +++ b/examples/sample_pr_result.json @@ -0,0 +1,7 @@ +{ + "pr_url": "https://github.com/your-org/your-repo/pull/42", + "pr_number": 42, + "branch": "infoundry/iac-aws-20251211-120000", + "repository": "your-org/your-repo", + "files_uploaded": ["main.tf", "variables.tf", "outputs.tf"] +} diff --git a/examples/sample_service_profile.json b/examples/sample_service_profile.json new file mode 100644 index 0000000..86f452a --- /dev/null +++ b/examples/sample_service_profile.json @@ -0,0 +1,24 @@ +{ + "services": { + "backend": { + "path": "repo/backend", + "has_dockerfile": true, + "language": "javascript", + "framework": "express", + "ports": [8000], + "databases": ["postgres", "redis"], + "queues": [] + }, + "frontend": { + "path": "repo/frontend", + "has_dockerfile": false, + "language": "javascript", + "framework": "nextjs", + "ports": [3000], + "databases": [], + "queues": [] + } + }, + "repo_url": "https://github.com/crypticsaiyan/GlobSEO.git", + "service_count": 2 +} diff --git a/examples/sample_telemetry_summary.json b/examples/sample_telemetry_summary.json new file mode 100644 index 0000000..57e22b3 --- /dev/null +++ b/examples/sample_telemetry_summary.json @@ -0,0 +1,24 @@ +{ + "summary": { + "backend": { + "p50": 140, + "p95": 450, + "avg_latency": 220, + "error_rate": 0.02, + "cost": 60, + "cpu_usage": 0.7, + "memory_mb": 512 + }, + "frontend": { + "p50": 90, + "p95": 170, + "avg_latency": 120, + "error_rate": 0.01, + "cost": 35, + "cpu_usage": 0.4, + "memory_mb": 256 + } + }, + "collected_at": "2025-12-11T08:00:00.000000", + "source": "mock" +} diff --git a/examples/telemetry/metrics.json b/examples/telemetry/metrics.json deleted file mode 100644 index 33d338b..0000000 --- a/examples/telemetry/metrics.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "auth": { - "latencies": [120, 140, 200, 450, 500, 320, 280, 260, 150, 130], - "errors": [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], - "cost": 60 - }, - "payments": { - "latencies": [90, 110, 130, 150, 170, 190, 210, 230, 250, 270], - "errors": [0, 0, 0, 0, 0, 0, 0, 0, 0, 1], - "cost": 35 - } -} - diff --git a/infoundry-mcp-server/README.md b/infoundry-mcp-server/README.md new file mode 100644 index 0000000..ff70fcc --- /dev/null +++ b/infoundry-mcp-server/README.md @@ -0,0 +1,69 @@ +# InFoundry MCP Server + +Model Context Protocol server exposing InFoundry's cloud architecture workflow to [Cline CLI](https://cline.bot). + +## Tools (9 Steps - Mirrors Kestra Pipeline) + +| Step | Tool | Description | +|------|------|-------------| +| 1 | `ingest_repo` | Analyze repository (local or GitHub URL) for services, DBs, queues | +| 2 | `ingest_telemetry` | Collect service telemetry (latency, errors, CPU, memory) | +| 3 | `propose_architecture` | AI architecture proposal using Oumi model | +| 4 | `render_graph` | Convert architecture to React Flow graph for UI | +| 5 | `generate_iac` | Generate Terraform from architecture graph | +| 6 | `validate_iac` | Validate Terraform (fmt, init, validate, tflint) | +| 7 | `create_pr` | Create GitHub PR with IaC files | +| 8 | `validate_pr` | Check PR status, CI checks, and reviews | +| 9 | `evaluate` | AI evaluation with recommendations | + +## Setup + +```bash +npm install +npm run build +``` + +## Configure with Cline + +Add to `~/.config/cline/mcp.json`: + +```json +{ + "mcpServers": { + "infoundry-architect": { + "command": "node", + "args": ["/path/to/infoundry/infoundry-mcp-server/dist/index.js"], + "env": { + "GITHUB_TOKEN": "ghp_YOUR_GITHUB_TOKEN_HERE" + } + } + } +} +``` + +## Example Workflow + +```bash +# Full pipeline with Cline +cline "Analyze https://github.com/my-org/my-app, propose architecture, generate Terraform, and create a PR" + +# Or step by step: +cline "Ingest repository at /path/to/repo" +cline "Propose architecture for the service profile" +cline "Generate Terraform and validate it" +cline "Create a PR with the IaC files" +``` + +## Environment Variables + +| Variable | Purpose | +|----------|---------| +| `GITHUB_TOKEN` | Required for create_pr, validate_pr | +| `KESTRA_URL` | Kestra API URL (default: localhost:8080) | + +## Test + +```bash +# From project root: +node tests/test_mcp_server.mjs +``` diff --git a/infoundry-mcp-server/mcp.json.example b/infoundry-mcp-server/mcp.json.example new file mode 100644 index 0000000..12ba9ab --- /dev/null +++ b/infoundry-mcp-server/mcp.json.example @@ -0,0 +1,11 @@ +{ + "mcpServers": { + "infoundry-architect": { + "command": "node", + "args": ["/path/to/infoundry/infoundry-mcp-server/dist/index.js"], + "env": { + "GITHUB_TOKEN": "ghp_YOUR_GITHUB_TOKEN_HERE" + } + } + } +} diff --git a/infoundry-mcp-server/package-lock.json b/infoundry-mcp-server/package-lock.json new file mode 100644 index 0000000..37b61d1 --- /dev/null +++ b/infoundry-mcp-server/package-lock.json @@ -0,0 +1,1667 @@ +{ + "name": "infoundry-mcp-server", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "infoundry-mcp-server", + "version": "1.0.0", + "license": "Apache-2.0", + "dependencies": { + "@modelcontextprotocol/sdk": "^1.0.0", + "zod": "^3.22.0" + }, + "bin": { + "infoundry-mcp": "dist/index.js" + }, + "devDependencies": { + "@types/node": "^20.10.0", + "tsx": "^4.7.0", + "typescript": "^5.3.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.1.tgz", + "integrity": "sha512-HHB50pdsBX6k47S4u5g/CaLjqS3qwaOVE5ILsq64jyzgMhLuCuZ8rGzM9yhsAjfjkbgUPMzZEPa7DAp7yz6vuA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.1.tgz", + "integrity": "sha512-kFqa6/UcaTbGm/NncN9kzVOODjhZW8e+FRdSeypWe6j33gzclHtwlANs26JrupOntlcWmB0u8+8HZo8s7thHvg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.1.tgz", + "integrity": "sha512-45fuKmAJpxnQWixOGCrS+ro4Uvb4Re9+UTieUY2f8AEc+t7d4AaZ6eUJ3Hva7dtrxAAWHtlEFsXFMAgNnGU9uQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.1.tgz", + "integrity": "sha512-LBEpOz0BsgMEeHgenf5aqmn/lLNTFXVfoWMUox8CtWWYK9X4jmQzWjoGoNb8lmAYml/tQ/Ysvm8q7szu7BoxRQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.1.tgz", + "integrity": "sha512-veg7fL8eMSCVKL7IW4pxb54QERtedFDfY/ASrumK/SbFsXnRazxY4YykN/THYqFnFwJ0aVjiUrVG2PwcdAEqQQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.1.tgz", + "integrity": "sha512-+3ELd+nTzhfWb07Vol7EZ+5PTbJ/u74nC6iv4/lwIU99Ip5uuY6QoIf0Hn4m2HoV0qcnRivN3KSqc+FyCHjoVQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.1.tgz", + "integrity": "sha512-/8Rfgns4XD9XOSXlzUDepG8PX+AVWHliYlUkFI3K3GB6tqbdjYqdhcb4BKRd7C0BhZSoaCxhv8kTcBrcZWP+xg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.1.tgz", + "integrity": "sha512-GITpD8dK9C+r+5yRT/UKVT36h/DQLOHdwGVwwoHidlnA168oD3uxA878XloXebK4Ul3gDBBIvEdL7go9gCUFzQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.1.tgz", + "integrity": "sha512-ieMID0JRZY/ZeCrsFQ3Y3NlHNCqIhTprJfDgSB3/lv5jJZ8FX3hqPyXWhe+gvS5ARMBJ242PM+VNz/ctNj//eA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.1.tgz", + "integrity": "sha512-W9//kCrh/6in9rWIBdKaMtuTTzNj6jSeG/haWBADqLLa9P8O5YSRDzgD5y9QBok4AYlzS6ARHifAb75V6G670Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.1.tgz", + "integrity": "sha512-VIUV4z8GD8rtSVMfAj1aXFahsi/+tcoXXNYmXgzISL+KB381vbSTNdeZHHHIYqFyXcoEhu9n5cT+05tRv13rlw==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.1.tgz", + "integrity": "sha512-l4rfiiJRN7sTNI//ff65zJ9z8U+k6zcCg0LALU5iEWzY+a1mVZ8iWC1k5EsNKThZ7XCQ6YWtsZ8EWYm7r1UEsg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.1.tgz", + "integrity": "sha512-U0bEuAOLvO/DWFdygTHWY8C067FXz+UbzKgxYhXC0fDieFa0kDIra1FAhsAARRJbvEyso8aAqvPdNxzWuStBnA==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.1.tgz", + "integrity": "sha512-NzdQ/Xwu6vPSf/GkdmRNsOfIeSGnh7muundsWItmBsVpMoNPVpM61qNzAVY3pZ1glzzAxLR40UyYM23eaDDbYQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.1.tgz", + "integrity": "sha512-7zlw8p3IApcsN7mFw0O1Z1PyEk6PlKMu18roImfl3iQHTnr/yAfYv6s4hXPidbDoI2Q0pW+5xeoM4eTCC0UdrQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.1.tgz", + "integrity": "sha512-cGj5wli+G+nkVQdZo3+7FDKC25Uh4ZVwOAK6A06Hsvgr8WqBBuOy/1s+PUEd/6Je+vjfm6stX0kmib5b/O2Ykw==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.1.tgz", + "integrity": "sha512-z3H/HYI9MM0HTv3hQZ81f+AKb+yEoCRlUby1F80vbQ5XdzEMyY/9iNlAmhqiBKw4MJXwfgsh7ERGEOhrM1niMA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.1.tgz", + "integrity": "sha512-wzC24DxAvk8Em01YmVXyjl96Mr+ecTPyOuADAvjGg+fyBpGmxmcr2E5ttf7Im8D0sXZihpxzO1isus8MdjMCXQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.1.tgz", + "integrity": "sha512-1YQ8ybGi2yIXswu6eNzJsrYIGFpnlzEWRl6iR5gMgmsrR0FcNoV1m9k9sc3PuP5rUBLshOZylc9nqSgymI+TYg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.1.tgz", + "integrity": "sha512-5Z+DzLCrq5wmU7RDaMDe2DVXMRm2tTDvX2KU14JJVBN2CT/qov7XVix85QoJqHltpvAOZUAc3ndU56HSMWrv8g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.1.tgz", + "integrity": "sha512-Q73ENzIdPF5jap4wqLtsfh8YbYSZ8Q0wnxplOlZUOyZy7B4ZKW8DXGWgTCZmF8VWD7Tciwv5F4NsRf6vYlZtqg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.1.tgz", + "integrity": "sha512-ajbHrGM/XiK+sXM0JzEbJAen+0E+JMQZ2l4RR4VFwvV9JEERx+oxtgkpoKv1SevhjavK2z2ReHk32pjzktWbGg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.1.tgz", + "integrity": "sha512-IPUW+y4VIjuDVn+OMzHc5FV4GubIwPnsz6ubkvN8cuhEqH81NovB53IUlrlBkPMEPxvNnf79MGBoz8rZ2iW8HA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.1.tgz", + "integrity": "sha512-RIVRWiljWA6CdVu8zkWcRmGP7iRRIIwvhDKem8UMBjPql2TXM5PkDVvvrzMtj1V+WFPB4K7zkIGM7VzRtFkjdg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.1.tgz", + "integrity": "sha512-2BR5M8CPbptC1AK5JbJT1fWrHLvejwZidKx3UMSF0ecHMa+smhi16drIrCEggkgviBwLYd5nwrFLSl5Kho96RQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.1.tgz", + "integrity": "sha512-d5X6RMYv6taIymSk8JBP+nxv8DQAMY6A51GPgusqLdK9wBz5wWIXy1KjTck6HnjE9hqJzJRdk+1p/t5soSbCtw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@modelcontextprotocol/sdk": { + "version": "1.24.3", + "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.24.3.tgz", + "integrity": "sha512-YgSHW29fuzKKAHTGe9zjNoo+yF8KaQPzDC2W9Pv41E7/57IfY+AMGJ/aDFlgTLcVVELoggKE4syABCE75u3NCw==", + "license": "MIT", + "dependencies": { + "ajv": "^8.17.1", + "ajv-formats": "^3.0.1", + "content-type": "^1.0.5", + "cors": "^2.8.5", + "cross-spawn": "^7.0.5", + "eventsource": "^3.0.2", + "eventsource-parser": "^3.0.0", + "express": "^5.0.1", + "express-rate-limit": "^7.5.0", + "jose": "^6.1.1", + "pkce-challenge": "^5.0.0", + "raw-body": "^3.0.0", + "zod": "^3.25 || ^4.0", + "zod-to-json-schema": "^3.25.0" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@cfworker/json-schema": "^4.1.1", + "zod": "^3.25 || ^4.0" + }, + "peerDependenciesMeta": { + "@cfworker/json-schema": { + "optional": true + }, + "zod": { + "optional": false + } + } + }, + "node_modules/@types/node": { + "version": "20.19.26", + "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.26.tgz", + "integrity": "sha512-0l6cjgF0XnihUpndDhk+nyD3exio3iKaYROSgvh/qSevPXax3L8p5DBRFjbvalnwatGgHEQn2R88y2fA3g4irg==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~6.21.0" + } + }, + "node_modules/accepts": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz", + "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==", + "license": "MIT", + "dependencies": { + "mime-types": "^3.0.0", + "negotiator": "^1.0.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/ajv": { + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz", + "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3", + "fast-uri": "^3.0.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ajv-formats": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz", + "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==", + "license": "MIT", + "dependencies": { + "ajv": "^8.0.0" + }, + "peerDependencies": { + "ajv": "^8.0.0" + }, + "peerDependenciesMeta": { + "ajv": { + "optional": true + } + } + }, + "node_modules/body-parser": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.1.tgz", + "integrity": "sha512-nfDwkulwiZYQIGwxdy0RUmowMhKcFVcYXUU7m4QlKYim1rUtg83xm2yjZ40QjDuc291AJjjeSc9b++AWHSgSHw==", + "license": "MIT", + "dependencies": { + "bytes": "^3.1.2", + "content-type": "^1.0.5", + "debug": "^4.4.3", + "http-errors": "^2.0.0", + "iconv-lite": "^0.7.0", + "on-finished": "^2.4.1", + "qs": "^6.14.0", + "raw-body": "^3.0.1", + "type-is": "^2.0.1" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", + "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/content-disposition": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.1.tgz", + "integrity": "sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q==", + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", + "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz", + "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==", + "license": "MIT", + "engines": { + "node": ">=6.6.0" + } + }, + "node_modules/cors": { + "version": "2.8.5", + "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz", + "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==", + "license": "MIT", + "dependencies": { + "object-assign": "^4", + "vary": "^1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==", + "license": "MIT" + }, + "node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-object-atoms": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz", + "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/esbuild": { + "version": "0.27.1", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.1.tgz", + "integrity": "sha512-yY35KZckJJuVVPXpvjgxiCuVEJT67F6zDeVTv4rizyPrfGBUpZQsvmxnN+C371c2esD/hNMjj4tpBhuueLN7aA==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.27.1", + "@esbuild/android-arm": "0.27.1", + "@esbuild/android-arm64": "0.27.1", + "@esbuild/android-x64": "0.27.1", + "@esbuild/darwin-arm64": "0.27.1", + "@esbuild/darwin-x64": "0.27.1", + "@esbuild/freebsd-arm64": "0.27.1", + "@esbuild/freebsd-x64": "0.27.1", + "@esbuild/linux-arm": "0.27.1", + "@esbuild/linux-arm64": "0.27.1", + "@esbuild/linux-ia32": "0.27.1", + "@esbuild/linux-loong64": "0.27.1", + "@esbuild/linux-mips64el": "0.27.1", + "@esbuild/linux-ppc64": "0.27.1", + "@esbuild/linux-riscv64": "0.27.1", + "@esbuild/linux-s390x": "0.27.1", + "@esbuild/linux-x64": "0.27.1", + "@esbuild/netbsd-arm64": "0.27.1", + "@esbuild/netbsd-x64": "0.27.1", + "@esbuild/openbsd-arm64": "0.27.1", + "@esbuild/openbsd-x64": "0.27.1", + "@esbuild/openharmony-arm64": "0.27.1", + "@esbuild/sunos-x64": "0.27.1", + "@esbuild/win32-arm64": "0.27.1", + "@esbuild/win32-ia32": "0.27.1", + "@esbuild/win32-x64": "0.27.1" + } + }, + "node_modules/escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==", + "license": "MIT" + }, + "node_modules/etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/eventsource": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz", + "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==", + "license": "MIT", + "dependencies": { + "eventsource-parser": "^3.0.1" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/eventsource-parser": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.6.tgz", + "integrity": "sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg==", + "license": "MIT", + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/express": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz", + "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==", + "license": "MIT", + "dependencies": { + "accepts": "^2.0.0", + "body-parser": "^2.2.1", + "content-disposition": "^1.0.0", + "content-type": "^1.0.5", + "cookie": "^0.7.1", + "cookie-signature": "^1.2.1", + "debug": "^4.4.0", + "depd": "^2.0.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "etag": "^1.8.1", + "finalhandler": "^2.1.0", + "fresh": "^2.0.0", + "http-errors": "^2.0.0", + "merge-descriptors": "^2.0.0", + "mime-types": "^3.0.0", + "on-finished": "^2.4.1", + "once": "^1.4.0", + "parseurl": "^1.3.3", + "proxy-addr": "^2.0.7", + "qs": "^6.14.0", + "range-parser": "^1.2.1", + "router": "^2.2.0", + "send": "^1.1.0", + "serve-static": "^2.2.0", + "statuses": "^2.0.1", + "type-is": "^2.0.1", + "vary": "^1.1.2" + }, + "engines": { + "node": ">= 18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/express-rate-limit": { + "version": "7.5.1", + "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.5.1.tgz", + "integrity": "sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw==", + "license": "MIT", + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://github.com/sponsors/express-rate-limit" + }, + "peerDependencies": { + "express": ">= 4.11" + } + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "license": "MIT" + }, + "node_modules/fast-uri": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz", + "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fastify" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/fastify" + } + ], + "license": "BSD-3-Clause" + }, + "node_modules/finalhandler": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.1.tgz", + "integrity": "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==", + "license": "MIT", + "dependencies": { + "debug": "^4.4.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "on-finished": "^2.4.1", + "parseurl": "^1.3.3", + "statuses": "^2.0.1" + }, + "engines": { + "node": ">= 18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fresh": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz", + "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/get-tsconfig": { + "version": "4.13.0", + "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.0.tgz", + "integrity": "sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "resolve-pkg-maps": "^1.0.0" + }, + "funding": { + "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/http-errors": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", + "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", + "license": "MIT", + "dependencies": { + "depd": "~2.0.0", + "inherits": "~2.0.4", + "setprototypeof": "~1.2.0", + "statuses": "~2.0.2", + "toidentifier": "~1.0.1" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/iconv-lite": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.1.tgz", + "integrity": "sha512-2Tth85cXwGFHfvRgZWszZSvdo+0Xsqmw8k8ZwxScfcBneNUraK+dxRxRm24nszx80Y0TVio8kKLt5sLE7ZCLlw==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" + }, + "node_modules/ipaddr.js": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", + "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/is-promise": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz", + "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==", + "license": "MIT" + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "license": "ISC" + }, + "node_modules/jose": { + "version": "6.1.3", + "resolved": "https://registry.npmjs.org/jose/-/jose-6.1.3.tgz", + "integrity": "sha512-0TpaTfihd4QMNwrz/ob2Bp7X04yuxJkjRGi4aKmOqwhov54i6u79oCv7T+C7lo70MKH6BesI3vscD1yb/yzKXQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/panva" + } + }, + "node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "license": "MIT" + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/media-typer": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz", + "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/merge-descriptors": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz", + "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==", + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mime-db": { + "version": "1.54.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz", + "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.2.tgz", + "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==", + "license": "MIT", + "dependencies": { + "mime-db": "^1.54.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/negotiator": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz", + "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-inspect": { + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", + "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-to-regexp": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.3.0.tgz", + "integrity": "sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA==", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/pkce-challenge": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.1.tgz", + "integrity": "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==", + "license": "MIT", + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", + "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", + "license": "MIT", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/qs": { + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz", + "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==", + "license": "BSD-3-Clause", + "dependencies": { + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/range-parser": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", + "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/raw-body": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.2.tgz", + "integrity": "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==", + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "http-errors": "~2.0.1", + "iconv-lite": "~0.7.0", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve-pkg-maps": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", + "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" + } + }, + "node_modules/router": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz", + "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==", + "license": "MIT", + "dependencies": { + "debug": "^4.4.0", + "depd": "^2.0.0", + "is-promise": "^4.0.0", + "parseurl": "^1.3.3", + "path-to-regexp": "^8.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "license": "MIT" + }, + "node_modules/send": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/send/-/send-1.2.0.tgz", + "integrity": "sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==", + "license": "MIT", + "dependencies": { + "debug": "^4.3.5", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "etag": "^1.8.1", + "fresh": "^2.0.0", + "http-errors": "^2.0.0", + "mime-types": "^3.0.1", + "ms": "^2.1.3", + "on-finished": "^2.4.1", + "range-parser": "^1.2.1", + "statuses": "^2.0.1" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/serve-static": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.0.tgz", + "integrity": "sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==", + "license": "MIT", + "dependencies": { + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "parseurl": "^1.3.3", + "send": "^1.2.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "license": "ISC" + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/side-channel": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz", + "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3", + "side-channel-list": "^1.0.0", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz", + "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/statuses": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", + "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "license": "MIT", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/tsx": { + "version": "4.21.0", + "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz", + "integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "~0.27.0", + "get-tsconfig": "^4.7.5" + }, + "bin": { + "tsx": "dist/cli.mjs" + }, + "engines": { + "node": ">=18.0.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + } + }, + "node_modules/type-is": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.0.1.tgz", + "integrity": "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==", + "license": "MIT", + "dependencies": { + "content-type": "^1.0.5", + "media-typer": "^1.1.0", + "mime-types": "^3.0.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", + "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "license": "ISC" + }, + "node_modules/zod": { + "version": "3.25.76", + "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz", + "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + }, + "node_modules/zod-to-json-schema": { + "version": "3.25.0", + "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.0.tgz", + "integrity": "sha512-HvWtU2UG41LALjajJrML6uQejQhNJx+JBO9IflpSja4R03iNWfKXrj6W2h7ljuLyc1nKS+9yDyL/9tD1U/yBnQ==", + "license": "ISC", + "peerDependencies": { + "zod": "^3.25 || ^4" + } + } + } +} diff --git a/infoundry-mcp-server/package.json b/infoundry-mcp-server/package.json new file mode 100644 index 0000000..9b654ec --- /dev/null +++ b/infoundry-mcp-server/package.json @@ -0,0 +1,26 @@ +{ + "name": "infoundry-mcp-server", + "version": "1.0.0", + "description": "MCP server exposing InFoundry cloud architecture tools to Cline", + "main": "dist/index.js", + "type": "module", + "bin": { + "infoundry-mcp": "./dist/index.js" + }, + "scripts": { + "build": "tsc", + "start": "node dist/index.js", + "dev": "tsx src/index.ts" + }, + "keywords": ["mcp", "cline", "terraform", "cloud-architecture"], + "license": "MIT", + "dependencies": { + "@modelcontextprotocol/sdk": "^1.0.0", + "zod": "^3.22.0" + }, + "devDependencies": { + "@types/node": "^20.10.0", + "tsx": "^4.7.0", + "typescript": "^5.3.0" + } +} diff --git a/infoundry-mcp-server/src/index.ts b/infoundry-mcp-server/src/index.ts new file mode 100644 index 0000000..1025da1 --- /dev/null +++ b/infoundry-mcp-server/src/index.ts @@ -0,0 +1,887 @@ +#!/usr/bin/env node +/** + * InFoundry MCP Server + * + * Exposes cloud architecture tools to Cline via Model Context Protocol. + * Tools mirror the InFoundry Kestra pipeline exactly: + * 1. ingest_repo - Analyze repository + * 2. ingest_telemetry - Collect service telemetry + * 3. propose_architecture - AI architecture proposal (Oumi) + * 4. render_graph - Convert architecture to React Flow graph + * 5. generate_iac - Generate Terraform from graph + * 6. validate_iac - Validate Terraform + * 7. create_pr - Create GitHub PR with IaC + * 8. validate_pr - Check PR status and reviews + * 9. evaluate - AI evaluation of deployment results + */ + +import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"; +import { z } from "zod"; +import { spawnSync } from "child_process"; +import * as fs from "fs"; +import * as path from "path"; + +const server = new McpServer({ + name: "infoundry-architect", + version: "1.0.0", +}); + +/** + * Validate and sanitize a path to prevent command injection. + */ +function validatePath(inputPath: string): string { + const resolved = path.resolve(inputPath); + + if (inputPath.includes(';') || inputPath.includes('&&') || + inputPath.includes('|') || inputPath.includes('`') || + inputPath.includes('$(') || inputPath.includes('\n')) { + throw new Error(`Invalid path: contains dangerous characters`); + } + + if (!fs.existsSync(resolved)) { + throw new Error(`Path does not exist: ${resolved}`); + } + + const stats = fs.statSync(resolved); + if (!stats.isDirectory()) { + throw new Error(`Path is not a directory: ${resolved}`); + } + + return resolved; +} + +// ============== STEP 1: ingest_repo ============== +server.tool( + "ingest_repo", + "Analyze a repository to detect services, databases, and queues. Supports local paths or GitHub URLs.", + { + repoPath: z.string().describe("Local path OR GitHub URL (e.g., https://github.com/owner/repo)"), + }, + async ({ repoPath }) => { + const services: Record = {}; + const databases: string[] = []; + const queues: string[] = []; + let tempDir: string | null = null; + let analyzePath: string; + let primaryLanguage = "unknown"; + let sourceUrl = repoPath; + + try { + const githubMatch = repoPath.match(/^https?:\/\/github\.com\/([^\/]+)\/([^\/]+?)(\.git)?$/); + + if (githubMatch) { + const owner = githubMatch[1]; + const repo = githubMatch[2]; + tempDir = `/tmp/infoundry-analyze-${owner}-${repo}-${Date.now()}`; + + const cloneResult = spawnSync('git', ['clone', '--depth', '1', repoPath, tempDir], { + encoding: 'utf-8', + timeout: 60000, + }); + + if (cloneResult.status !== 0) { + throw new Error(`Failed to clone repository: ${cloneResult.stderr}`); + } + + analyzePath = tempDir; + } else { + analyzePath = validatePath(repoPath); + sourceUrl = "local"; + } + + // Find Node.js services + const findResult = spawnSync('find', [ + analyzePath, '-name', 'package.json', + '-not', '-path', '*/node_modules/*', '-not', '-path', '*/.git/*' + ], { encoding: 'utf-8', timeout: 30000 }); + + const packageJsons = (findResult.stdout || '').trim().split('\n').filter(Boolean); + for (const pkg of packageJsons) { + const dir = path.dirname(pkg); + const name = path.basename(dir); + if (path.resolve(dir) !== path.resolve(analyzePath) && name !== '.' && !name.startsWith('.')) { + services[name] = { type: 'nodejs', path: dir.replace(tempDir || '', '') }; + primaryLanguage = "nodejs"; + } + } + + // Find Python services + const pythonResult = spawnSync('find', [ + analyzePath, '(', '-name', 'main.py', '-o', '-name', 'app.py', '-o', '-name', 'serve.py', ')', + '-not', '-path', '*/.git/*', '-not', '-path', '*/venv/*', '-not', '-path', '*/site-packages/*' + ], { encoding: 'utf-8', timeout: 30000 }); + + const pythonApps = (pythonResult.stdout || '').trim().split('\n').filter(Boolean); + for (const app of pythonApps) { + const dir = path.dirname(app); + const name = path.basename(dir); + if (!services[name] && path.resolve(dir) !== path.resolve(analyzePath) && name !== '.') { + services[name] = { type: 'python', path: dir.replace(tempDir || '', '') }; + if (primaryLanguage === "unknown") primaryLanguage = "python"; + } + } + + // Detect databases/queues from docker-compose + const dockerCompose = path.join(analyzePath, 'docker-compose.yml'); + if (fs.existsSync(dockerCompose)) { + const content = fs.readFileSync(dockerCompose, 'utf-8'); + if (content.includes('postgres')) databases.push('postgres'); + if (content.includes('mysql')) databases.push('mysql'); + if (content.includes('mongo')) databases.push('mongodb'); + if (content.includes('redis')) queues.push('redis'); + if (content.includes('rabbitmq')) queues.push('rabbitmq'); + } + + const profile = { + source: sourceUrl, + services, + databases, + queues, + service_count: Object.keys(services).length, + primary_language: primaryLanguage, + has_infrastructure: fs.existsSync(path.join(analyzePath, 'infra')) || fs.existsSync(path.join(analyzePath, 'terraform')), + analyzed_at: new Date().toISOString(), + }; + + if (tempDir && fs.existsSync(tempDir)) { + spawnSync('rm', ['-rf', tempDir], { timeout: 10000 }); + } + + return { content: [{ type: 'text', text: JSON.stringify(profile, null, 2) }] }; + } catch (error) { + if (tempDir && fs.existsSync(tempDir)) { + spawnSync('rm', ['-rf', tempDir], { timeout: 10000 }); + } + return { content: [{ type: 'text', text: `Error: ${error}` }], isError: true }; + } + } +); + +// ============== STEP 2: ingest_telemetry ============== +server.tool( + "ingest_telemetry", + "Collect and summarize service telemetry metrics (latency, error rate, CPU, memory)", + { + services: z.string().describe("Comma-separated service names to collect telemetry for"), + metricsJson: z.string().optional().describe("Optional JSON with real metrics, otherwise generates mock data"), + }, + async ({ services, metricsJson }) => { + try { + const serviceList = services.split(',').map(s => s.trim()).filter(Boolean); + let summary: Record = {}; + + if (metricsJson) { + summary = JSON.parse(metricsJson); + } else { + // Generate mock telemetry for demo + for (const service of serviceList) { + summary[service] = { + p50: Math.floor(Math.random() * 200) + 50, + p95: Math.floor(Math.random() * 400) + 150, + avg_latency: Math.floor(Math.random() * 250) + 80, + error_rate: Math.random() * 0.05, + cost: Math.floor(Math.random() * 80) + 20, + cpu_usage: Math.random() * 0.8 + 0.1, + memory_mb: Math.floor(Math.random() * 512) + 128, + }; + } + } + + const result = { + summary, + collected_at: new Date().toISOString(), + source: metricsJson ? "provided" : "mock", + }; + + return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] }; + } catch (error) { + return { content: [{ type: 'text', text: `Error: ${error}` }], isError: true }; + } + } +); + +// ============== STEP 3: propose_architecture ============== +server.tool( + "propose_architecture", + "Propose optimal cloud architecture using InFoundry's Oumi AI model", + { + serviceProfile: z.string().describe("JSON string of service profile from ingest_repo"), + telemetrySummary: z.string().optional().describe("JSON string of telemetry from ingest_telemetry"), + cloudProvider: z.string().optional().describe("Target cloud: aws, gcp, or azure (default: aws)"), + }, + async ({ serviceProfile, telemetrySummary, cloudProvider = "aws" }) => { + try { + const profile = JSON.parse(serviceProfile); + const serviceCount = profile.service_count || Object.keys(profile.services || {}).length; + const hasDatabase = (profile.databases?.length || 0) > 0; + const hasQueue = (profile.queues?.length || 0) > 0; + + let architecture: any = null; + + // Try Oumi model first (OpenAI-compatible endpoint) + try { + const prompt = `Recommend cloud architecture for: ${serviceCount} services, ${cloudProvider}, ${hasDatabase ? 'with database' : 'no database'}, ${hasQueue ? 'with queue' : 'no queue'}`; + + const response = await fetch("http://localhost:8000/v1/chat/completions", { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ + model: "oumi", + messages: [{ role: "user", content: prompt }], + }), + }); + + if (response.ok) { + const result = await response.json(); + const content = result.choices?.[0]?.message?.content; + if (content) { + try { + // Parse JSON from response + const jsonMatch = content.match(/\{[\s\S]*\}/); + if (jsonMatch) { + architecture = JSON.parse(jsonMatch[0]); + architecture.source = "oumi"; + } + } catch { + // JSON parse failed, use heuristic + } + } + } + } catch { + // Oumi not available + } + + // Fallback to heuristics + if (!architecture) { + let pattern: string; + let components: string[]; + + if (serviceCount <= 2) { + pattern = "serverless"; + components = ["api_gateway", "lambda_functions", "dynamodb"]; + } else if (serviceCount > 4) { + pattern = "kubernetes"; + components = ["eks_cluster", "alb", "rds", "elasticache"]; + } else { + pattern = "microservices_ecs"; + components = ["ecs_cluster", "alb", "rds"]; + } + + if (hasDatabase && !components.includes("rds")) components.push("rds"); + if (hasQueue) components.push("sqs"); + + architecture = { + pattern, + components, + topology: `${serviceCount} services with ${pattern} on ${cloudProvider}`, + scaling_strategy: serviceCount > 3 ? "horizontal_autoscaling" : "vertical_scaling", + estimated_cost_tier: serviceCount > 4 ? "high" : serviceCount > 2 ? "medium" : "low", + rationale: `Selected ${pattern} for ${serviceCount} services with ${hasDatabase ? 'database' : 'no database'}`, + source: "heuristic", + }; + } + + const result = { + architecture, + inputs: { + service_count: serviceCount, + cloud_provider: cloudProvider, + primary_language: profile.primary_language || "unknown", + }, + source: architecture.source, + proposed_at: new Date().toISOString(), + }; + + return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] }; + } catch (error) { + return { content: [{ type: "text", text: `Error: ${error}` }], isError: true }; + } + } +); + +// ============== STEP 4: render_graph ============== +server.tool( + "render_graph", + "Convert architecture plan to React Flow graph format for UI visualization", + { + architecturePlan: z.string().describe("JSON string of architecture plan from propose_architecture"), + }, + async ({ architecturePlan }) => { + try { + const plan = JSON.parse(architecturePlan); + const arch = plan.architecture || plan; + const components: string[] = arch.components || []; + const pattern = arch.pattern || "unknown"; + const scalingStrategy = arch.scaling_strategy || "vertical_scaling"; + + // Component styling + const STYLES: Record = { + api_gateway: { icon: "globe", color: "#FF9800", category: "network", tier: 1 }, + alb: { icon: "share-2", color: "#2196F3", category: "network", tier: 1 }, + ecs_cluster: { icon: "box", color: "#4CAF50", category: "compute", tier: 2 }, + eks_cluster: { icon: "layers", color: "#9C27B0", category: "compute", tier: 2 }, + lambda_functions: { icon: "zap", color: "#FF5722", category: "compute", tier: 2 }, + rds: { icon: "database", color: "#3F51B5", category: "database", tier: 3 }, + dynamodb: { icon: "grid", color: "#009688", category: "database", tier: 3 }, + elasticache: { icon: "cpu", color: "#E91E63", category: "cache", tier: 3 }, + sqs: { icon: "mail", color: "#607D8B", category: "messaging", tier: 3 }, + s3: { icon: "archive", color: "#795548", category: "storage", tier: 3 }, + }; + + // Create nodes + const byTier: Record = {}; + for (const comp of components) { + const style = STYLES[comp] || { tier: 5 }; + byTier[style.tier] = byTier[style.tier] || []; + byTier[style.tier].push(comp); + } + + let xOffset = 0; + const nodes: any[] = []; + const positions: Record = {}; + + for (const tier of Object.keys(byTier).map(Number).sort()) { + const tierComps = byTier[tier]; + const startY = -(tierComps.length * 150) / 2 + 75; + tierComps.forEach((comp, i) => { + positions[comp] = { x: xOffset, y: startY + i * 150 }; + }); + xOffset += 280; + } + + for (const comp of components) { + const style = STYLES[comp] || { icon: "box", color: "#999", category: "other", tier: 5 }; + nodes.push({ + id: comp, + type: "infrastructureNode", + data: { + label: comp.replace(/_/g, " ").replace(/\b\w/g, c => c.toUpperCase()), + type: comp, + icon: style.icon, + category: style.category, + }, + position: positions[comp] || { x: 0, y: 0 }, + style: { background: style.color, borderRadius: "8px" }, + }); + } + + // Create edges + const EDGES: Record = { + api_gateway: ["lambda_functions", "ecs_cluster", "eks_cluster"], + alb: ["ecs_cluster", "eks_cluster"], + ecs_cluster: ["rds", "elasticache", "dynamodb", "sqs", "s3"], + eks_cluster: ["rds", "elasticache", "dynamodb", "sqs", "s3"], + lambda_functions: ["dynamodb", "s3", "sqs", "rds"], + }; + + const edges: any[] = []; + const compSet = new Set(components); + let edgeId = 0; + + for (const [source, targets] of Object.entries(EDGES)) { + if (compSet.has(source)) { + for (const target of targets) { + if (compSet.has(target)) { + edges.push({ + id: `e${edgeId++}`, + source, + target, + type: "smoothstep", + animated: source === "api_gateway" || source === "alb", + }); + } + } + } + } + + const graph = { + nodes, + edges, + metadata: { + pattern, + scaling_strategy: scalingStrategy, + component_count: nodes.length, + edge_count: edges.length, + source: plan.source || "unknown", + cloud_provider: plan.inputs?.cloud_provider || "aws", + generated_at: new Date().toISOString(), + }, + }; + + return { content: [{ type: "text", text: JSON.stringify(graph, null, 2) }] }; + } catch (error) { + return { content: [{ type: "text", text: `Error: ${error}` }], isError: true }; + } + } +); + +// ============== STEP 5: generate_iac ============== +server.tool( + "generate_iac", + "Generate Terraform IaC from architecture graph", + { + graph: z.string().describe("JSON string of graph from render_graph"), + cloudProvider: z.string().optional().describe("Cloud provider (default: aws)"), + projectName: z.string().optional().describe("Project name for resource naming"), + outputDir: z.string().optional().describe("Directory to write files (if provided, writes to disk)"), + }, + async ({ graph, cloudProvider = "aws", projectName = "infoundry", outputDir }) => { + try { + const graphData = JSON.parse(graph); + const components = graphData.nodes?.map((n: any) => n.id) || graphData.metadata?.components || []; + const pattern = graphData.metadata?.pattern || "unknown"; + + const templates: Record = { + api_gateway: `resource "aws_api_gateway_rest_api" "main" { + name = "${projectName}-api" +}`, + lambda_functions: `resource "aws_lambda_function" "main" { + function_name = "${projectName}-handler" + runtime = "python3.11" + handler = "main.handler" + role = aws_iam_role.lambda.arn +}`, + dynamodb: `resource "aws_dynamodb_table" "main" { + name = "${projectName}-data" + billing_mode = "PAY_PER_REQUEST" + hash_key = "id" + + attribute { + name = "id" + type = "S" + } +}`, + ecs_cluster: `resource "aws_ecs_cluster" "main" { + name = "${projectName}-cluster" +}`, + eks_cluster: `resource "aws_eks_cluster" "main" { + name = "${projectName}-eks" + role_arn = aws_iam_role.eks.arn + + vpc_config { + subnet_ids = var.subnet_ids + } +}`, + alb: `resource "aws_lb" "main" { + name = "${projectName}-alb" + load_balancer_type = "application" + subnets = var.public_subnet_ids +}`, + rds: `resource "aws_db_instance" "main" { + identifier = "${projectName}-db" + engine = "postgres" + instance_class = var.db_instance_class + username = var.db_username + password = var.db_password + skip_final_snapshot = true +}`, + elasticache: `resource "aws_elasticache_cluster" "main" { + cluster_id = "${projectName}-cache" + engine = "redis" + node_type = "cache.t3.micro" + num_cache_nodes = 1 +}`, + sqs: `resource "aws_sqs_queue" "main" { + name = "${projectName}-queue" +}`, + s3: `resource "aws_s3_bucket" "main" { + bucket = "${projectName}-storage" +}`, + }; + + let mainTf = `# Generated by InFoundry +# Pattern: ${pattern} + +terraform { + required_version = ">= 1.0" + + required_providers { + aws = { + source = "hashicorp/aws" + version = "~> 5.0" + } + } +} + +provider "aws" { + region = var.aws_region +} +`; + + for (const comp of components) { + if (templates[comp]) { + mainTf += `\n# ${comp.toUpperCase()}\n${templates[comp]}\n`; + } + } + + const variablesTf = `variable "aws_region" { + default = "us-east-1" +} + +variable "environment" { + default = "dev" +} + +variable "db_instance_class" { + default = "db.t3.micro" +} + +variable "db_username" { + sensitive = true +} + +variable "db_password" { + sensitive = true +} + +variable "subnet_ids" { + type = list(string) + default = [] +} + +variable "public_subnet_ids" { + type = list(string) + default = [] +} +`; + + const result: any = { + success: true, + pattern, + components, + files: { + "main.tf": mainTf, + "variables.tf": variablesTf, + }, + generated_at: new Date().toISOString(), + }; + + if (outputDir) { + const resolvedDir = path.resolve(outputDir); + fs.mkdirSync(resolvedDir, { recursive: true }); + fs.writeFileSync(path.join(resolvedDir, "main.tf"), mainTf); + fs.writeFileSync(path.join(resolvedDir, "variables.tf"), variablesTf); + result.output_dir = resolvedDir; + } + + return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] }; + } catch (error) { + return { content: [{ type: "text", text: `Error: ${error}` }], isError: true }; + } + } +); + +// ============== STEP 6: validate_iac ============== +server.tool( + "validate_iac", + "Validate Terraform with fmt, init, validate, and optional tflint", + { + iacDir: z.string().describe("Directory containing Terraform files"), + }, + async ({ iacDir }) => { + const results: Record = {}; + + try { + const safePath = validatePath(iacDir); + + // terraform fmt + try { + const fmtResult = spawnSync('terraform', ['fmt', '-check', '-recursive'], { cwd: safePath, encoding: 'utf-8' }); + results.terraform_fmt = { success: fmtResult.status === 0, message: fmtResult.status === 0 ? "Passed" : "Needs formatting" }; + } catch (e: any) { + results.terraform_fmt = { success: false, message: e.message }; + } + + // terraform init + validate + try { + const initResult = spawnSync('terraform', ['init', '-backend=false'], { cwd: safePath, encoding: 'utf-8' }); + if (initResult.status === 0) { + const validateResult = spawnSync('terraform', ['validate'], { cwd: safePath, encoding: 'utf-8' }); + results.terraform_validate = { success: validateResult.status === 0, message: validateResult.status === 0 ? "Valid" : validateResult.stderr }; + } else { + results.terraform_validate = { success: false, message: "Init failed: " + initResult.stderr }; + } + } catch (e: any) { + results.terraform_validate = { success: false, message: e.message }; + } + + // tflint (optional) + try { + const lintResult = spawnSync('tflint', [], { cwd: safePath, encoding: 'utf-8' }); + if (lintResult.error && (lintResult.error as any).code === 'ENOENT') { + results.tflint = { skipped: true, message: "tflint not installed" }; + } else { + results.tflint = { success: lintResult.status === 0, output: lintResult.stdout }; + } + } catch { + results.tflint = { skipped: true, message: "tflint not available" }; + } + + const allPassed = Object.values(results).every((r: any) => r?.success || r?.skipped); + + return { + content: [{ type: "text", text: JSON.stringify({ + valid: allPassed, + deploy_status: allPassed ? "validated" : "failed", + checks: results, + validated_at: new Date().toISOString(), + }, null, 2) }], + }; + } catch (error) { + return { content: [{ type: "text", text: `Error: ${error}` }], isError: true }; + } + } +); + +// ============== STEP 7: create_pr ============== +server.tool( + "create_pr", + "Create a GitHub PR with generated IaC files", + { + repository: z.string().describe("GitHub repository in owner/repo format"), + files: z.union([z.string(), z.record(z.string())]).describe("Files as JSON string or object with filename: content pairs"), + targetFolder: z.string().optional().describe("Target folder in repo (default: infra)"), + baseBranch: z.string().optional().describe("Base branch (default: main)"), + labels: z.union([z.string(), z.array(z.string())]).optional().describe("Labels to add (comma-separated string or array)"), + }, + async ({ repository, files, targetFolder = "infra", baseBranch = "main", labels }) => { + // Handle both string and object input for files + const fileMap: Record = typeof files === 'string' ? JSON.parse(files) : files; + // Handle labels as string or array + const labelList: string[] = labels + ? (typeof labels === 'string' ? labels.split(',').map(l => l.trim()) : labels) + : ['infoundry', 'infrastructure']; + const githubToken = process.env.GITHUB_TOKEN; + + if (!githubToken) { + return { + content: [{ type: "text", text: JSON.stringify({ + success: false, + error: "GITHUB_TOKEN not set", + hint: "export GITHUB_TOKEN=ghp_...", + }, null, 2) }], + isError: true, + }; + } + + try { + const timestamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14); + const branch = `infoundry/iac-${timestamp}`; + + const headers = { + "Authorization": `token ${githubToken}`, + "Accept": "application/vnd.github.v3+json", + "Content-Type": "application/json", + "User-Agent": "InFoundry-MCP-Server", + }; + + const apiBase = `https://api.github.com/repos/${repository}`; + + // Get base SHA + const refResponse = await fetch(`${apiBase}/git/refs/heads/${baseBranch}`, { headers }); + if (!refResponse.ok) throw new Error(`Failed to get base branch`); + const refData = await refResponse.json(); + const baseSha = refData.object.sha; + + // Create branch + await fetch(`${apiBase}/git/refs`, { + method: "POST", + headers, + body: JSON.stringify({ ref: `refs/heads/${branch}`, sha: baseSha }), + }); + + // Upload files + for (const [filename, content] of Object.entries(fileMap)) { + const filePath = `${targetFolder}/${filename}`; + await fetch(`${apiBase}/contents/${filePath}`, { + method: "PUT", + headers, + body: JSON.stringify({ + message: `Add ${filename} via InFoundry`, + content: Buffer.from(content as string).toString("base64"), + branch, + }), + }); + } + + // Create PR + const prResponse = await fetch(`${apiBase}/pulls`, { + method: "POST", + headers, + body: JSON.stringify({ + title: `[InFoundry] Infrastructure Update ${timestamp}`, + body: "This PR was automatically generated by InFoundry Architect.", + head: branch, + base: baseBranch, + }), + }); + + if (!prResponse.ok) throw new Error(`Failed to create PR: ${await prResponse.text()}`); + const prData = await prResponse.json(); + + // Add labels to PR + if (labelList.length > 0) { + await fetch(`${apiBase}/issues/${prData.number}/labels`, { + method: "POST", + headers, + body: JSON.stringify({ labels: labelList }), + }); + } + + return { + content: [{ type: "text", text: JSON.stringify({ + success: true, + pr_url: prData.html_url, + pr_number: prData.number, + branch, + files: Object.keys(fileMap), + labels: labelList, + }, null, 2) }], + }; + } catch (error) { + return { content: [{ type: "text", text: `Error: ${error}` }], isError: true }; + } + } +); + +// ============== STEP 8: validate_pr ============== +server.tool( + "validate_pr", + "Check PR status including CI checks and CodeRabbit reviews", + { + repository: z.string().describe("GitHub repository in owner/repo format"), + prNumber: z.number().describe("Pull Request number"), + }, + async ({ repository, prNumber }) => { + const githubToken = process.env.GITHUB_TOKEN; + const headers: Record = { + "Accept": "application/vnd.github.v3+json", + "User-Agent": "InFoundry-MCP-Server", + }; + if (githubToken) headers["Authorization"] = `token ${githubToken}`; + + try { + // Get PR details + const prResponse = await fetch(`https://api.github.com/repos/${repository}/pulls/${prNumber}`, { headers }); + if (!prResponse.ok) throw new Error(`PR not found`); + const pr = await prResponse.json(); + + // Get CI checks + const checksResponse = await fetch(`https://api.github.com/repos/${repository}/commits/${pr.head.sha}/check-runs`, { headers }); + let checks: any[] = []; + if (checksResponse.ok) { + const checksData = await checksResponse.json(); + checks = (checksData.check_runs || []).map((c: any) => ({ + name: c.name, + status: c.status, + conclusion: c.conclusion, + })); + } + + // Get reviews + const reviewsResponse = await fetch(`https://api.github.com/repos/${repository}/pulls/${prNumber}/reviews`, { headers }); + let reviews: any[] = []; + if (reviewsResponse.ok) { + reviews = (await reviewsResponse.json()).map((r: any) => ({ + user: r.user?.login, + state: r.state, + })); + } + + const allChecksPassed = checks.every(c => c.conclusion === "success" || c.status !== "completed"); + const hasApproval = reviews.some(r => r.state === "APPROVED"); + + return { + content: [{ type: "text", text: JSON.stringify({ + pr_number: prNumber, + state: pr.state, + mergeable: pr.mergeable, + draft: pr.draft, + checks, + reviews, + all_checks_passed: allChecksPassed, + has_approval: hasApproval, + ready_to_merge: pr.mergeable && allChecksPassed && !pr.draft, + validated_at: new Date().toISOString(), + }, null, 2) }], + }; + } catch (error) { + return { content: [{ type: "text", text: `Error: ${error}` }], isError: true }; + } + } +); + +// ============== STEP 9: evaluate ============== +server.tool( + "evaluate", + "AI evaluation of deployment/validation results with recommendations", + { + deployResult: z.string().describe("JSON string of validation/deployment result from validate_iac"), + }, + async ({ deployResult }) => { + try { + const deploy = JSON.parse(deployResult); + let score = 0; + let recommendation = "review"; + const feedback: string[] = []; + const improvements: string[] = []; + + // Calculate score based on validation results + if (deploy.valid || deploy.deploy_status === "validated") { + score += 0.5; + feedback.push("Terraform validation passed"); + } else { + feedback.push("Terraform validation failed"); + improvements.push("Fix validation errors before deploying"); + } + + if (deploy.checks?.terraform_fmt?.success) { + score += 0.2; + } else { + improvements.push("Run 'terraform fmt' to fix formatting"); + } + + if (deploy.checks?.terraform_validate?.success) { + score += 0.2; + } + + if (deploy.checks?.tflint?.success || deploy.checks?.tflint?.skipped) { + score += 0.1; + } else { + improvements.push("Address tflint warnings for best practices"); + } + + // Determine recommendation + if (score >= 0.8) { + recommendation = "proceed"; + } else if (score >= 0.5) { + recommendation = "review"; + } else { + recommendation = "reject"; + } + + const result = { + score: Math.round(score * 100) / 100, + recommendation, + feedback: feedback.join(". "), + improvements, + source: "infoundry-evaluator", + evaluated_at: new Date().toISOString(), + }; + + return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] }; + } catch (error) { + return { content: [{ type: "text", text: `Error: ${error}` }], isError: true }; + } + } +); + +// Start server +async function main() { + const transport = new StdioServerTransport(); + await server.connect(transport); + console.error("InFoundry MCP Server running on stdio - 9 workflow tools available"); +} + +main().catch(console.error); diff --git a/infoundry-mcp-server/tsconfig.json b/infoundry-mcp-server/tsconfig.json new file mode 100644 index 0000000..e9005d0 --- /dev/null +++ b/infoundry-mcp-server/tsconfig.json @@ -0,0 +1,16 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "NodeNext", + "moduleResolution": "NodeNext", + "outDir": "./dist", + "rootDir": "./src", + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true, + "forceConsistentCasingInFileNames": true, + "declaration": true + }, + "include": ["src/**/*"], + "exclude": ["node_modules", "dist"] +} diff --git a/infra/.gitkeep b/infra/.gitkeep deleted file mode 100644 index 139597f..0000000 --- a/infra/.gitkeep +++ /dev/null @@ -1,2 +0,0 @@ - - diff --git a/infra/modules/.gitkeep b/infra/modules/.gitkeep deleted file mode 100644 index 139597f..0000000 --- a/infra/modules/.gitkeep +++ /dev/null @@ -1,2 +0,0 @@ - - diff --git a/infra/templates/.gitkeep b/infra/templates/.gitkeep deleted file mode 100644 index 139597f..0000000 --- a/infra/templates/.gitkeep +++ /dev/null @@ -1,2 +0,0 @@ - - diff --git a/orchestrator/__init__.py b/orchestrator/__init__.py deleted file mode 100644 index 139597f..0000000 --- a/orchestrator/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ - - diff --git a/orchestrator/cline_integration.py b/orchestrator/cline_integration.py deleted file mode 100644 index 9353182..0000000 --- a/orchestrator/cline_integration.py +++ /dev/null @@ -1,49 +0,0 @@ -""" -Stub for Cline CLI integration. -This module demonstrates how to render IaC templates and open PRs via Cline. -""" -import subprocess -from pathlib import Path -from typing import Dict - - -def render_iac(service: str, template_dir: Path, output_dir: Path) -> Path: - output_dir.mkdir(parents=True, exist_ok=True) - sample = output_dir / f"{service}-hpa.tf" - sample.write_text( - f'# Placeholder Terraform for {service}\nresource "null_resource" "{service}_hpa" {{}}\n' - ) - return sample - - -def create_pr(repo: str, branch: str, title: str, files: Path) -> None: - cmd = [ - "cline", - "pr", - "create", - "--repo", - repo, - "--branch", - branch, - "--title", - title, - "--files", - str(files), - ] - try: - subprocess.run(cmd, check=True) - except FileNotFoundError: - print("cline CLI not installed; skipping actual PR creation.") - - -def propose_change(service: str, repo: str = "your-org/cloudgenesis") -> Path: - template_dir = Path("infra/templates") - output_dir = Path("infra/generated") / service - rendered = render_iac(service, template_dir, output_dir) - create_pr(repo, f"cloudgenesis/{service}", f"Auto: optimize {service}", rendered) - return rendered - - -if __name__ == "__main__": - propose_change("auth") - diff --git a/orchestrator/kestra_pipelines/00-end-to-end.yaml b/orchestrator/kestra_pipelines/00-end-to-end.yaml new file mode 100644 index 0000000..1b8c1aa --- /dev/null +++ b/orchestrator/kestra_pipelines/00-end-to-end.yaml @@ -0,0 +1,216 @@ +id: end-to-end +namespace: infoundry + +description: | + Master pipeline that chains all InFoundry steps. + Flow: ingest β†’ propose β†’ render β†’ generate β†’ validate β†’ create-pr β†’ validate-pr β†’ evaluate + +inputs: + - id: repo_url + type: STRING + required: true + description: Git repository URL to analyze + + - id: branch + type: STRING + required: true + defaults: "main" + description: Git branch to clone + + - id: repository + type: STRING + required: true + defaults: "crypticsaiyan/infotest" + description: GitHub repository for PR creation (owner/repo) + + - id: cloud_provider + type: STRING + required: true + defaults: "aws" + description: Target cloud provider + + - id: project_name + type: STRING + required: true + defaults: "infoundry" + description: Project name for resource naming + + - id: target_folder + type: STRING + required: true + defaults: "infra" + description: Target folder in repo for Terraform files + + - id: skip_pr + type: BOOLEAN + required: true + defaults: false + description: Skip PR creation step + + - id: skip_validation + type: BOOLEAN + required: true + defaults: false + description: Skip validation step + +tasks: + # Step 1: Ingest repository + - id: ingest_repo + type: io.kestra.plugin.core.flow.Subflow + flowId: ingest-repo + namespace: infoundry + inputs: + repo_url: "{{ inputs.repo_url }}" + branch: "{{ inputs.branch }}" + wait: true + + # Step 2: Ingest telemetry (optional) + - id: ingest_telemetry + type: io.kestra.plugin.core.flow.Subflow + flowId: ingest-telemetry + namespace: infoundry + allowFailure: true + inputs: + services: "backend,frontend" + wait: true + + # Step 3: Propose architecture (AI-powered via Oumi) + - id: propose_architecture + type: io.kestra.plugin.core.flow.Subflow + flowId: propose-architecture + namespace: infoundry + inputs: + service_profile: "{{ outputs.ingest_repo.outputs.service_profile }}" + telemetry_summary: "{{ outputs.ingest_telemetry.outputs.telemetry_summary ?? '' }}" + wait: true + + # Step 4: Render graph + - id: render_graph + type: io.kestra.plugin.core.flow.Subflow + flowId: render-graph + namespace: infoundry + inputs: + architecture_plan: "{{ outputs.propose_architecture.outputs.architecture_plan }}" + wait: true + + # Step 5: Generate IaC (AI-powered via Kestra AI Agent + Ollama) + - id: generate_iac + type: io.kestra.plugin.core.flow.Subflow + flowId: generate-iac + namespace: infoundry + inputs: + graph: "{{ outputs.render_graph.outputs.graph }}" + cloud_provider: "{{ inputs.cloud_provider }}" + project_name: "{{ inputs.project_name }}" + wait: true + + # Step 6: Validate IaC (terraform init, validate, fmt, plan) + - id: validate_iac + type: io.kestra.plugin.core.flow.Subflow + flowId: validate-iac + namespace: infoundry + runIf: "{{ inputs.skip_validation != true }}" + inputs: + iac_bundle: "{{ outputs.generate_iac.outputs.iac_bundle }}" + wait: true + + # Step 7: Create PR (only if validation passed) + - id: create_pr + type: io.kestra.plugin.core.flow.Subflow + flowId: create-pr + namespace: infoundry + runIf: "{{ inputs.skip_pr != true }}" + inputs: + iac_bundle: "{{ outputs.generate_iac.outputs.iac_bundle }}" + repository: "{{ inputs.repository }}" + target_folder: "{{ inputs.target_folder }}" + wait: true + + # Step 8: Validate PR (monitor checks and CodeRabbit reviews) + - id: validate_pr + type: io.kestra.plugin.core.flow.Subflow + flowId: validate-pr + namespace: infoundry + runIf: "{{ inputs.skip_pr != true }}" + allowFailure: true + inputs: + pr_result: "{{ outputs.create_pr.outputs.pr_result }}" + repository: "{{ inputs.repository }}" + wait: true + + # Step 9: Evaluate (AI-powered evaluation) + - id: evaluate + type: io.kestra.plugin.core.flow.Subflow + flowId: evaluate + namespace: infoundry + runIf: "{{ inputs.skip_validation != true }}" + allowFailure: true + inputs: + deploy_result: "{{ outputs.validate_iac.outputs.deploy_result }}" + wait: true + + # Step 10: Log summary + - id: log_summary + type: io.kestra.plugin.scripts.python.Script + script: | + print("=" * 50) + print("InFoundry End-to-End Pipeline Complete!") + print("=" * 50) + print("") + print("Repository: {{ inputs.repo_url }}") + print("Cloud Provider: {{ inputs.cloud_provider }}") + print("Project Name: {{ inputs.project_name }}") + print("") + print("Steps completed:") + print(" βœ… 01. Repository ingested") + print(" βœ… 02. Telemetry collected") + print(" βœ… 03. Architecture proposed") + print(" βœ… 04. Graph rendered") + print(" βœ… 05. IaC generated") + print(" βœ… 06. Terraform validated") + print(" βœ… 07. PR created") + print(" βœ… 08. PR checks monitored") + print(" βœ… 09. Results evaluated") + print("") + print("Output files available in workflow outputs.") + +outputs: + - id: service_profile + type: FILE + value: "{{ outputs.ingest_repo.outputs.service_profile }}" + description: Service profile from repository analysis + + - id: architecture_plan + type: FILE + value: "{{ outputs.propose_architecture.outputs.architecture_plan }}" + description: AI-proposed architecture plan + + - id: graph + type: FILE + value: "{{ outputs.render_graph.outputs.graph }}" + description: Architecture graph JSON + + - id: iac_bundle + type: FILE + value: "{{ outputs.generate_iac.outputs.iac_bundle }}" + description: Generated Terraform ZIP bundle + + - id: iac_manifest + type: FILE + value: "{{ outputs.generate_iac.outputs.iac_manifest }}" + description: IaC manifest with AI decisions + + - id: validation_result + type: FILE + value: "{{ outputs.validate_iac.outputs.deploy_result ?? null }}" + description: Terraform validation result + + - id: pr_result + type: FILE + value: "{{ outputs.create_pr.outputs.pr_result ?? null }}" + description: PR creation result + + - id: evaluation_result + type: FILE + value: "{{ outputs.evaluate.outputs.evaluation_result ?? null }}" + description: AI evaluation result diff --git a/orchestrator/kestra_pipelines/01-ingest-repo.yaml b/orchestrator/kestra_pipelines/01-ingest-repo.yaml new file mode 100644 index 0000000..0eafb9a --- /dev/null +++ b/orchestrator/kestra_pipelines/01-ingest-repo.yaml @@ -0,0 +1,474 @@ +id: ingest-repo +namespace: infoundry + +description: Analyzes a git repo to detect services and components + +inputs: + - id: repo_url + type: STRING + required: true + description: Git repository URL to analyze + + - id: branch + type: STRING + required: false + description: Git branch to clone + +tasks: + # Extract owner/repo from the GitHub URL + - id: parse_repo_url + type: io.kestra.plugin.scripts.python.Script + outputFiles: + - repo_info.json + script: | + import json + import re + + url = "{{ inputs.repo_url }}" + # Extract owner/repo from various GitHub URL formats + patterns = [ + r'github\.com[:/]([^/]+)/([^/.]+?)(?:\.git)?$', # HTTPS or SSH + r'github\.com/([^/]+)/([^/]+?)/?$' # Web URL + ] + + owner, repo = None, None + for pattern in patterns: + match = re.search(pattern, url) + if match: + owner, repo = match.groups() + break + + info = {"owner": owner, "repo": repo, "full_name": f"{owner}/{repo}" if owner else None} + with open("repo_info.json", "w") as f: + json.dump(info, f) + print(json.dumps(info, indent=2)) + + # Fetch programming languages from GitHub API + - id: fetch_languages + type: io.kestra.plugin.core.http.Request + uri: "https://api.github.com/repos/{{ read(outputs.parse_repo_url.outputFiles['repo_info.json']) | jq('.owner') | first }}/{{ read(outputs.parse_repo_url.outputFiles['repo_info.json']) | jq('.repo') | first }}/languages" + method: GET + headers: + Accept: "application/vnd.github+json" + User-Agent: "infoundry-kestra" + + - id: working_dir + type: io.kestra.plugin.core.flow.WorkingDirectory + outputFiles: + - service_profile.json + tasks: + - id: clone_repository + type: io.kestra.plugin.git.Clone + url: "{{ inputs.repo_url }}" + branch: "{{ inputs.branch ?? 'main' }}" + depth: 1 + + - id: analyze_repo + type: io.kestra.plugin.scripts.python.Script + env: + GITHUB_LANGUAGES: "{{ outputs.fetch_languages.body }}" + script: | + import json + import os + import re + import subprocess + import sys + from pathlib import Path + from collections import defaultdict + + # ============================================================================= + # CHECK FOR USER-PROVIDED SERVICE PROFILE + # If the user has placed a service_profile.json in .infoundry/, use it directly + # ============================================================================= + + USER_PROFILE_PATH = Path(".infoundry/service_profile.json") + if USER_PROFILE_PATH.exists(): + try: + with open(USER_PROFILE_PATH) as f: + profile = json.load(f) + + # Add repo URL and source marker + profile["repo_url"] = "{{ inputs.repo_url }}" + profile["source"] = "user-provided" + + # Ensure required fields exist + if "services" not in profile: + raise ValueError("Missing required 'services' field") + if "service_count" not in profile: + profile["service_count"] = len(profile.get("services", {})) + if "languages" not in profile: + profile["languages"] = [] + if "primary_language" not in profile: + profile["primary_language"] = "unknown" + + # Write output and exit + with open("service_profile.json", "w") as f: + json.dump(profile, f, indent=2) + + print("=== USING USER-PROVIDED SERVICE PROFILE ===") + print(f"Source: {USER_PROFILE_PATH}") + print(json.dumps(profile, indent=2)) + sys.exit(0) + + except Exception as e: + print(f"Warning: Found .infoundry/service_profile.json but failed to parse: {e}") + print("Falling back to auto-detection...") + + # ============================================================================= + # OPTIMIZED SERVICE DETECTION ALGORITHM + # Complexity: O(1) Disk I/O (git index) + O(N) Memory (string filtering) + # ============================================================================= + + # Parse GitHub Languages API response + GITHUB_LANGUAGES_RAW = os.environ.get("GITHUB_LANGUAGES", "{}") + try: + GITHUB_LANGUAGES = json.loads(GITHUB_LANGUAGES_RAW) + except json.JSONDecodeError: + GITHUB_LANGUAGES = {} + + if GITHUB_LANGUAGES: + PRIMARY_LANGUAGE = max(GITHUB_LANGUAGES.keys(), key=lambda k: GITHUB_LANGUAGES[k]).lower() + ALL_LANGUAGES = [lang.lower() for lang in GITHUB_LANGUAGES.keys()] + else: + PRIMARY_LANGUAGE = "" + ALL_LANGUAGES = [] + + # Normalize GitHub language names + LANG_MAP = {"c++": "cpp", "c#": "csharp", "objective-c": "objectivec"} + PRIMARY_LANGUAGE = LANG_MAP.get(PRIMARY_LANGUAGE, PRIMARY_LANGUAGE) + ALL_LANGUAGES = [LANG_MAP.get(l, l) for l in ALL_LANGUAGES] + + # Service root markers - files that indicate the root of a service + ROOT_MARKERS = ["package.json", "go.mod", "pom.xml", "requirements.txt", "pyproject.toml", "Cargo.toml", "Dockerfile", "build.gradle", "CMakeLists.txt", "Gemfile"] + + # Common service directory patterns + SERVICE_DIRS = [".", "src", "backend", "frontend", "server", "client", "api", "app", "apps", "services", "packages", "libs", "web"] + + # ============================================================================= + # STEP 1: FAST MARKER SCAN (O(dirs * markers) instead of O(all files)) + # ============================================================================= + def find_markers_fast(): + """Directly scan for marker files in common locations - much faster than os.walk.""" + services = {} + + # Check root level first + root_markers = [m for m in ROOT_MARKERS if Path(m).exists()] + if root_markers: + services["main"] = { + "markers": root_markers, + "path": "." + } + + # Check common service directories (depth 1) + for d in SERVICE_DIRS: + if d == ".": + continue + dir_path = Path(d) + if dir_path.exists() and dir_path.is_dir(): + markers = [f"{d}/{m}" for m in ROOT_MARKERS if (dir_path / m).exists()] + if markers: + services[d] = { + "markers": markers, + "path": d + } + + # Check one level deeper for monorepo patterns (packages/*, apps/*, services/*) + monorepo_roots = ["packages", "apps", "services", "libs"] + for mono_root in monorepo_roots: + mono_path = Path(mono_root) + if mono_path.exists() and mono_path.is_dir(): + try: + for subdir in mono_path.iterdir(): + if subdir.is_dir() and not subdir.name.startswith("."): + markers = [f"{mono_root}/{subdir.name}/{m}" for m in ROOT_MARKERS if (subdir / m).exists()] + if markers: + services[f"{mono_root}/{subdir.name}"] = { + "markers": markers, + "path": f"{mono_root}/{subdir.name}" + } + except PermissionError: + pass + + return services + + # ============================================================================= + # STEP 3: PARSE STRUCTURED FILES (targeted reads only) + # ============================================================================= + def parse_package_json(filepath): + """Parse package.json and extract dependencies.""" + try: + with open(filepath) as f: + pkg = json.load(f) + deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})} + scripts = pkg.get("scripts", {}) + return {"deps": deps, "scripts": scripts, "name": pkg.get("name", "")} + except: + return {"deps": {}, "scripts": {}, "name": ""} + + def parse_requirements_txt(filepath): + """Parse requirements.txt and extract package names.""" + try: + with open(filepath) as f: + lines = f.readlines() + deps = [] + for line in lines: + line = line.strip().lower() + if line and not line.startswith("#"): + # Extract package name (before ==, >=, etc.) + pkg = re.split(r"[=<>~!]", line)[0].strip() + if pkg: + deps.append(pkg) + return deps + except: + return [] + + def parse_go_mod(filepath): + """Parse go.mod and extract module dependencies.""" + try: + with open(filepath) as f: + content = f.read() + deps = re.findall(r'^\s*(\S+)\s+v', content, re.MULTILINE) + return deps + except: + return [] + + def detect_language_from_markers(markers, service_path): + """Detect language based on marker files present.""" + marker_names = [Path(m).name for m in markers] + path = Path(service_path) + + # Check for TypeScript indicators + if "package.json" in marker_names: + tsconfig_exists = (path / "tsconfig.json").exists() + if tsconfig_exists: + return "typescript" + pkg_data = parse_package_json(path / "package.json") + deps = pkg_data["deps"] + if "typescript" in deps or any(k.startswith("@types/") for k in deps): + return "typescript" + return "javascript" + + if "requirements.txt" in marker_names or "pyproject.toml" in marker_names: + return "python" + if "go.mod" in marker_names: + return "go" + if "Cargo.toml" in marker_names: + return "rust" + if "pom.xml" in marker_names or "build.gradle" in marker_names: + return "java" + if "CMakeLists.txt" in marker_names: + return "cpp" + if "Gemfile" in marker_names: + return "ruby" + + return PRIMARY_LANGUAGE or "unknown" + + def detect_framework(markers, service_path, lang): + """Detect framework by parsing dependency files.""" + path = Path(service_path) + + if lang in ("javascript", "typescript"): + if (path / "package.json").exists(): + pkg_data = parse_package_json(path / "package.json") + deps = pkg_data["deps"] + if "next" in deps: + return "nextjs" + if "express" in deps: + return "express" + if "fastify" in deps: + return "fastify" + if "@nestjs/core" in deps: + return "nestjs" + if "react" in deps: + return "react" + if "vue" in deps: + return "vue" + if "@angular/core" in deps: + return "angular" + if "svelte" in deps: + return "svelte" + + elif lang == "python": + deps = [] + if (path / "requirements.txt").exists(): + deps = parse_requirements_txt(path / "requirements.txt") + if "fastapi" in deps: + return "fastapi" + if "django" in deps: + return "django" + if "flask" in deps: + return "flask" + + elif lang == "go": + if (path / "go.mod").exists(): + deps = parse_go_mod(path / "go.mod") + dep_str = " ".join(deps).lower() + if "gin-gonic" in dep_str: + return "gin" + if "gorilla/mux" in dep_str: + return "gorilla" + if "fiber" in dep_str: + return "fiber" + if "echo" in dep_str: + return "echo" + + return None + + def detect_databases(markers, service_path, lang): + """Detect databases by parsing dependency keys (not text grep).""" + path = Path(service_path) + databases = [] + + db_packages = { + "postgres": ["pg", "postgres", "psycopg2", "psycopg", "asyncpg", "pgx"], + "mysql": ["mysql", "mysql2", "pymysql", "mysqlclient"], + "mongodb": ["mongodb", "mongoose", "pymongo", "motor"], + "redis": ["redis", "ioredis", "aioredis"], + "sqlite": ["sqlite3", "better-sqlite3", "aiosqlite"], + "elasticsearch": ["elasticsearch", "@elastic/elasticsearch"] + } + + deps = set() + if (path / "package.json").exists(): + pkg_data = parse_package_json(path / "package.json") + deps.update(k.lower() for k in pkg_data["deps"].keys()) + if (path / "requirements.txt").exists(): + deps.update(parse_requirements_txt(path / "requirements.txt")) + + for db, packages in db_packages.items(): + if any(pkg in deps for pkg in packages): + databases.append(db) + + return databases + + def detect_queues(markers, service_path, lang): + """Detect message queues by parsing dependency keys.""" + path = Path(service_path) + queues = [] + + queue_packages = { + "rabbitmq": ["amqplib", "amqp", "pika", "aio-pika"], + "kafka": ["kafkajs", "kafka-python", "confluent-kafka"], + "redis": ["bull", "bullmq", "celery", "rq"], + "sqs": ["@aws-sdk/client-sqs", "boto3"] + } + + deps = set() + if (path / "package.json").exists(): + pkg_data = parse_package_json(path / "package.json") + deps.update(k.lower() for k in pkg_data["deps"].keys()) + if (path / "requirements.txt").exists(): + deps.update(parse_requirements_txt(path / "requirements.txt")) + + for queue, packages in queue_packages.items(): + if any(pkg in deps for pkg in packages): + queues.append(queue) + + return queues + + def detect_ports(markers, service_path): + """Detect exposed ports from Dockerfile and package.json scripts.""" + path = Path(service_path) + ports = [] + + # Parse Dockerfile EXPOSE + dockerfile = path / "Dockerfile" + if dockerfile.exists(): + try: + content = dockerfile.read_text() + expose_matches = re.findall(r'EXPOSE\s+(\d+)', content) + ports.extend([int(p) for p in expose_matches]) + except: + pass + + # Parse package.json scripts for port flags + if (path / "package.json").exists(): + pkg_data = parse_package_json(path / "package.json") + for script in pkg_data["scripts"].values(): + port_match = re.search(r'-p\s*(\d+)|--port[=\s]+(\d+)|PORT[=\s]+(\d+)', str(script)) + if port_match: + port = next(p for p in port_match.groups() if p) + if int(port) not in ports: + ports.append(int(port)) + + return ports + + def analyze_service(service_name, service_data): + """Analyze a single service using its markers.""" + markers = service_data["markers"] + service_path = service_data["path"] + + lang = detect_language_from_markers(markers, service_path) + + return { + "path": service_path, + "has_dockerfile": "Dockerfile" in [Path(m).name for m in markers], + "language": lang, + "framework": detect_framework(markers, service_path, lang), + "ports": detect_ports(markers, service_path), + "databases": detect_databases(markers, service_path, lang), + "queues": detect_queues(markers, service_path, lang) + } + + # ============================================================================= + # MAIN EXECUTION + # ============================================================================= + try: + print("=== FAST SERVICE DETECTION ===") + print("Step 1: Scanning for service markers...") + service_markers = find_markers_fast() + print(f" Found {len(service_markers)} services") + + print("Step 2: Analyzing service configurations...") + services = {} + for service_name, service_data in service_markers.items(): + print(f" Analyzing: {service_name}") + try: + services[service_name] = analyze_service(service_name, service_data) + except Exception as e: + print(f" Error analyzing {service_name}: {e}") + services[service_name] = { + "path": service_data.get("path", "."), + "has_dockerfile": False, + "language": PRIMARY_LANGUAGE or "unknown", + "framework": None, + "ports": [], + "databases": [], + "queues": [], + "error": str(e) + } + + profile = { + "services": services, + "repo_url": "{{ inputs.repo_url }}", + "service_count": len(services), + "languages": ALL_LANGUAGES, + "primary_language": PRIMARY_LANGUAGE + } + + with open("service_profile.json", "w") as f: + json.dump(profile, f, indent=2) + print("\n=== OUTPUT ===") + print(json.dumps(profile, indent=2)) + + except Exception as e: + print(f"FATAL ERROR: {e}") + import traceback + traceback.print_exc() + # Still write an output file so the pipeline doesn't completely fail + profile = { + "services": {}, + "repo_url": "{{ inputs.repo_url }}", + "service_count": 0, + "languages": ALL_LANGUAGES, + "primary_language": PRIMARY_LANGUAGE, + "error": str(e) + } + with open("service_profile.json", "w") as f: + json.dump(profile, f, indent=2) + print(json.dumps(profile, indent=2)) + +outputs: + - id: service_profile + type: FILE + value: "{{ outputs.working_dir.outputFiles['service_profile.json'] }}" diff --git a/orchestrator/kestra_pipelines/02-ingest-telemetry.yaml b/orchestrator/kestra_pipelines/02-ingest-telemetry.yaml new file mode 100644 index 0000000..497b5fc --- /dev/null +++ b/orchestrator/kestra_pipelines/02-ingest-telemetry.yaml @@ -0,0 +1,74 @@ +id: ingest-telemetry +namespace: infoundry + +description: Fetches telemetry metrics (mock data for development) + +inputs: + - id: services + type: STRING + required: false + description: Comma-separated list of services + +tasks: + - id: generate_telemetry + type: io.kestra.plugin.scripts.python.Script + script: | + import json + import os + from datetime import datetime + + services_input = os.environ.get("SERVICES", "backend,frontend") + services = [s.strip() for s in services_input.split(",")] + + # Mock metrics data + MOCK_DATA = { + "backend": {"latencies": [120, 140, 200, 450, 500], "errors": [0, 0, 0, 1, 0], "cost": 60}, + "frontend": {"latencies": [90, 110, 130, 150, 170], "errors": [0, 0, 0, 0, 0], "cost": 35}, + "auth": {"latencies": [120, 140, 200, 450, 500], "errors": [0, 0, 0, 1, 0], "cost": 60}, + "payments": {"latencies": [90, 110, 130, 150, 170], "errors": [0, 0, 0, 0, 1], "cost": 35}, + } + DEFAULT = {"latencies": [100, 120, 140, 160, 180], "errors": [0, 0, 0, 0, 0], "cost": 25} + + def summarize(metrics): + lats = sorted(metrics.get("latencies", [])) + errs = metrics.get("errors", []) + n = len(lats) + if n == 0: + return { + "p50": 0, + "p95": 0, + "avg_latency": 0, + "error_rate": 0, + "cost": metrics.get("cost", 0) + } + return { + "p50": lats[n // 2], + "p95": lats[max(0, int(n * 0.95) - 1)], + "avg_latency": sum(lats) / n if n else 0, + "error_rate": sum(errs) / max(len(errs), 1), + "cost": metrics.get("cost", 0) + } + + summary = {} + for svc in services: + raw = MOCK_DATA.get(svc, DEFAULT) + summary[svc] = summarize(raw) + + output = { + "summary": summary, + "collected_at": datetime.utcnow().isoformat(), + "source": "mock" + } + + with open("telemetry_summary.json", "w") as f: + json.dump(output, f, indent=2) + print(json.dumps(output, indent=2)) + env: + SERVICES: "{{ inputs.services ?? 'backend,frontend' }}" + outputFiles: + - telemetry_summary.json + +outputs: + - id: telemetry_summary + type: FILE + value: "{{ outputs.generate_telemetry.outputFiles['telemetry_summary.json'] }}" diff --git a/orchestrator/kestra_pipelines/03-propose-architecture.yaml b/orchestrator/kestra_pipelines/03-propose-architecture.yaml new file mode 100644 index 0000000..7eeb630 --- /dev/null +++ b/orchestrator/kestra_pipelines/03-propose-architecture.yaml @@ -0,0 +1,205 @@ +id: propose-architecture +namespace: infoundry + +description: | + Proposes cloud architecture using the Oumi model server. + Calls the local serve.py FastAPI server. + +inputs: + - id: service_profile + type: FILE + required: true + description: Service profile JSON from ingest-repo flow + + - id: telemetry_summary + type: FILE + required: true + description: Telemetry summary JSON from ingest-telemetry flow + + - id: use_oumi + type: BOOLEAN + defaults: true + description: Use the Oumi model server (set false for heuristic only) + + - id: cloud_provider + type: STRING + defaults: "aws" + description: Target cloud provider (aws, gcp, azure) + + - id: oumi_server_url + type: STRING + defaults: "http://172.17.0.1:8000" + description: URL of the Oumi serve.py server + +tasks: + - id: working_dir + type: io.kestra.plugin.core.flow.WorkingDirectory + outputFiles: + - architecture_plan.json + tasks: + - id: download_inputs + type: io.kestra.plugin.core.storage.LocalFiles + inputs: + service_profile.json: "{{ inputs.service_profile }}" + telemetry_summary.json: "{{ inputs.telemetry_summary }}" + + - id: propose + type: io.kestra.plugin.scripts.python.Script + env: + USE_OUMI: "{{ inputs.use_oumi ?? 'true' }}" + CLOUD_PROVIDER: "{{ inputs.cloud_provider ?? 'aws' }}" + OUMI_SERVER: "{{ inputs.oumi_server_url ?? 'http://172.17.0.1:8000' }}" + script: | + import json + import os + import urllib.request + import urllib.error + + use_oumi = os.environ.get("USE_OUMI", "true").lower() == "true" + cloud_provider = os.environ.get("CLOUD_PROVIDER", "aws") + oumi_server = os.environ.get("OUMI_SERVER", "http://172.17.0.1:8000") + + # Load inputs + with open("service_profile.json") as f: + service_profile = json.load(f) + + with open("telemetry_summary.json") as f: + telemetry_summary = json.load(f) + + services = service_profile.get("services", {}) + telemetry = telemetry_summary.get("summary", {}) + languages = service_profile.get("languages", []) + primary_language = service_profile.get("primary_language", "unknown") + + def heuristic_proposal(services, telemetry, cloud_provider): + """Fallback when Oumi server unavailable.""" + num_services = len(services) + has_high_latency = any(s.get("p95", 0) > 400 for s in telemetry.values()) + total_cost = sum(s.get("cost", 0) for s in telemetry.values()) + + if num_services <= 2: + pattern = "serverless" + components = ["api_gateway", "lambda_functions", "dynamodb"] + elif num_services > 4: + pattern = "kubernetes" + components = ["eks_cluster", "alb", "rds", "elasticache"] + else: + pattern = "microservices_ecs" + components = ["ecs_cluster", "alb", "rds", "elasticache"] + + if has_high_latency: + components.extend(["hpa", "cdn"]) + + for svc in services.values(): + svc_str = str(svc).lower() + if "postgres" in svc_str and "rds" not in components: + components.append("rds") + if "redis" in svc_str and "elasticache" not in components: + components.append("elasticache") + + return { + "pattern": pattern, + "components": list(set(components)), + "topology": f"{num_services} services with {pattern} on {cloud_provider}", + "scaling_strategy": "horizontal_autoscaling" if has_high_latency else "vertical_scaling", + "estimated_cost_tier": "high" if total_cost > 100 else "medium" if total_cost > 50 else "low", + "rationale": f"Selected {pattern} for {num_services} services" + } + + def call_oumi_server(prompt, oumi_server): + """Call the local Oumi serve.py server.""" + api_url = f"{oumi_server}/v1/chat/completions" + + payload = { + "model": "oumi", + "messages": [{"role": "user", "content": prompt}], + "max_tokens": 512, + "temperature": 0.7 + } + + print(f"Calling Oumi server: {api_url}") + + try: + req = urllib.request.Request( + api_url, + data=json.dumps(payload).encode(), + headers={"Content-Type": "application/json"} + ) + + with urllib.request.urlopen(req, timeout=120) as resp: + result = json.load(resp) + if "choices" in result and len(result["choices"]) > 0: + content = result["choices"][0]["message"]["content"] + print(f"Oumi response: {content[:200]}...") + return content + return None + + except urllib.error.HTTPError as e: + print(f"Oumi server HTTP error {e.code}: {e.read().decode()}") + return None + except Exception as e: + print(f"Oumi server error: {e}") + return None + + def parse_response(response): + """Parse JSON from model response.""" + if not response: + return None + try: + start = response.find("{") + end = response.rfind("}") + 1 + if start >= 0 and end > start: + return json.loads(response[start:end]) + except json.JSONDecodeError as e: + print(f"JSON parse error: {e}") + return None + + # Build prompt for Oumi + service_list = list(services.keys()) + databases = [] + for svc in services.values(): + databases.extend(svc.get("databases", [])) + databases = list(set(databases)) + + prompt = f"Services: [{', '.join(service_list) if service_list else 'main'}], Language: {primary_language}, DB: {', '.join(databases) if databases else 'none'}, Cloud: {cloud_provider}" + + # Main execution + proposal = None + source = "heuristic" + + if use_oumi: + print("=== OUMI MODEL ARCHITECTURE PROPOSAL ===") + response = call_oumi_server(prompt, oumi_server) + proposal = parse_response(response) + if proposal: + source = "oumi" + print("Oumi model success!") + else: + print("Oumi failed, using heuristic...") + else: + print("=== HEURISTIC MODE ===") + + if not proposal: + proposal = heuristic_proposal(services, telemetry, cloud_provider) + + output = { + "architecture": proposal, + "inputs": { + "service_count": len(services), + "cloud_provider": cloud_provider, + "languages": languages, + "primary_language": primary_language + }, + "source": source + } + + with open("architecture_plan.json", "w") as f: + json.dump(output, f, indent=2) + + print("=== OUTPUT ===") + print(json.dumps(output, indent=2)) + +outputs: + - id: architecture_plan + type: FILE + value: "{{ outputs.working_dir.outputFiles['architecture_plan.json'] }}" diff --git a/orchestrator/kestra_pipelines/04-render-graph.yaml b/orchestrator/kestra_pipelines/04-render-graph.yaml new file mode 100644 index 0000000..fa5d77c --- /dev/null +++ b/orchestrator/kestra_pipelines/04-render-graph.yaml @@ -0,0 +1,278 @@ +id: render-graph +namespace: infoundry + +description: Converts architecture plan to React Flow graph format for UI + +inputs: + - id: architecture_plan + type: FILE + required: true + description: Architecture plan JSON from propose-architecture flow + +tasks: + - id: working_dir + type: io.kestra.plugin.core.flow.WorkingDirectory + outputFiles: + - graph.json + tasks: + - id: download_plan + type: io.kestra.plugin.core.storage.LocalFiles + inputs: + architecture_plan.json: "{{ inputs.architecture_plan }}" + + - id: render + type: io.kestra.plugin.scripts.python.Script + script: | + import json + import sys + from datetime import datetime + + # Extended component styling - aligned with 03-propose-architecture output + STYLES = { + # Network layer + "api_gateway": {"icon": "globe", "color": "#FF9800", "category": "network", "tier": 1}, + "alb": {"icon": "share-2", "color": "#2196F3", "category": "network", "tier": 1}, + "cdn": {"icon": "cloud", "color": "#00BCD4", "category": "network", "tier": 0}, + + # Compute layer + "ecs_cluster": {"icon": "box", "color": "#4CAF50", "category": "compute", "tier": 2}, + "eks_cluster": {"icon": "layers", "color": "#9C27B0", "category": "compute", "tier": 2}, + "lambda_functions": {"icon": "zap", "color": "#FF5722", "category": "compute", "tier": 2}, + "ec2": {"icon": "server", "color": "#66BB6A", "category": "compute", "tier": 2}, + + # Database layer + "rds": {"icon": "database", "color": "#3F51B5", "category": "database", "tier": 3}, + "dynamodb": {"icon": "grid", "color": "#009688", "category": "database", "tier": 3}, + "aurora": {"icon": "database", "color": "#5C6BC0", "category": "database", "tier": 3}, + + # Cache layer + "elasticache": {"icon": "cpu", "color": "#E91E63", "category": "cache", "tier": 3}, + "redis": {"icon": "cpu", "color": "#E91E63", "category": "cache", "tier": 3}, + + # Storage layer + "s3": {"icon": "archive", "color": "#795548", "category": "storage", "tier": 3}, + "efs": {"icon": "folder", "color": "#8D6E63", "category": "storage", "tier": 3}, + + # Messaging layer + "sqs": {"icon": "mail", "color": "#607D8B", "category": "messaging", "tier": 3}, + "sns": {"icon": "bell", "color": "#78909C", "category": "messaging", "tier": 3}, + "eventbridge": {"icon": "activity", "color": "#546E7A", "category": "messaging", "tier": 3}, + + # Scaling/monitoring + "hpa": {"icon": "trending-up", "color": "#8BC34A", "category": "scaling", "tier": 2}, + "cloudwatch": {"icon": "eye", "color": "#FFC107", "category": "monitoring", "tier": 4}, + "xray": {"icon": "crosshair", "color": "#FFEB3B", "category": "monitoring", "tier": 4}, + } + + # Connection rules - defines valid source -> target relationships + CONNECTIONS = { + # Network tier connections + "cdn": ["s3", "alb", "api_gateway"], + "api_gateway": ["lambda_functions", "ecs_cluster", "eks_cluster", "alb", "ec2"], + "alb": ["ecs_cluster", "eks_cluster", "lambda_functions", "ec2"], + + # Compute tier connections + "ecs_cluster": ["rds", "aurora", "elasticache", "redis", "dynamodb", "sqs", "sns", "s3"], + "eks_cluster": ["rds", "aurora", "elasticache", "redis", "dynamodb", "sqs", "sns", "s3"], + "lambda_functions": ["dynamodb", "s3", "sqs", "sns", "rds", "aurora", "elasticache", "eventbridge"], + "ec2": ["rds", "aurora", "elasticache", "s3", "efs"], + + # Scaling connections + "hpa": ["ecs_cluster", "eks_cluster"], + + # Messaging connections + "eventbridge": ["lambda_functions", "sqs", "sns"], + "sns": ["sqs", "lambda_functions"], + } + + def load_architecture_plan(filepath): + """Load and validate the architecture plan from 03-propose-architecture.""" + try: + with open(filepath) as f: + plan = json.load(f) + except FileNotFoundError: + print(f"ERROR: {filepath} not found") + sys.exit(1) + except json.JSONDecodeError as e: + print(f"ERROR: Invalid JSON in {filepath}: {e}") + sys.exit(1) + + # Validate expected structure from 03-propose-architecture + if "architecture" not in plan: + print("WARNING: 'architecture' key missing, using empty structure") + plan["architecture"] = {} + + return plan + + def normalize_component_name(comp): + """Normalize component names for consistent matching.""" + # Handle variations in naming + name = comp.lower().strip().replace("-", "_").replace(" ", "_") + + # Map common aliases + aliases = { + "lambda": "lambda_functions", + "lambdas": "lambda_functions", + "ecs": "ecs_cluster", + "eks": "eks_cluster", + "postgres": "rds", + "postgresql": "rds", + "mysql": "rds", + "cache": "elasticache", + "load_balancer": "alb", + "lb": "alb", + "cloudfront": "cdn", + "queue": "sqs", + "bucket": "s3", + } + return aliases.get(name, name) + + def create_nodes(components, pattern, scaling_strategy): + """Create React Flow nodes with tier-based HORIZONTAL positioning (left-to-right).""" + nodes = [] + + # Normalize and deduplicate components + normalized = [] + seen = set() + for comp in components: + norm = normalize_component_name(comp) + if norm not in seen: + normalized.append(norm) + seen.add(norm) + + # Group by tier for layout + by_tier = {} + for comp in normalized: + style = STYLES.get(comp, {"icon": "box", "color": "#999", "category": "other", "tier": 5}) + tier = style.get("tier", 5) + by_tier.setdefault(tier, []).append(comp) + + # Position nodes in HORIZONTAL tiered layout (left-to-right) + x_offset = 0 + node_positions = {} + for tier in sorted(by_tier.keys()): + tier_components = by_tier[tier] + tier_height = len(tier_components) * 150 + start_y = -tier_height // 2 + 75 + + for i, comp in enumerate(tier_components): + node_positions[comp] = {"x": x_offset, "y": start_y + i * 150} + x_offset += 280 # Horizontal spacing between tiers + + # Create node objects + for comp in normalized: + style = STYLES.get(comp, {"icon": "box", "color": "#999", "category": "other", "tier": 5}) + pos = node_positions.get(comp, {"x": 0, "y": 0}) + + # Determine if scaling is enabled for this component + has_scaling = scaling_strategy in ["horizontal_autoscaling", "auto"] and \ + comp in ["ecs_cluster", "eks_cluster", "lambda_functions"] + + nodes.append({ + "id": comp, + "type": "infrastructureNode", + "data": { + "label": comp.replace("_", " ").title(), + "type": comp, + "icon": style["icon"], + "category": style["category"], + "scaling": has_scaling + }, + "position": pos, + "style": { + "background": style["color"], + "borderRadius": "8px", + "border": "2px solid rgba(255,255,255,0.2)" + } + }) + + return nodes, normalized + + def create_edges(normalized_components): + """Create React Flow edges based on connection rules.""" + edges = [] + edge_id = 0 + comp_set = set(normalized_components) + + for source, targets in CONNECTIONS.items(): + if source in comp_set: + for target in targets: + if target in comp_set: + # Determine edge style based on source type + source_style = STYLES.get(source, {}) + is_animated = source_style.get("category") in ["network", "scaling"] + + edges.append({ + "id": f"e{edge_id}", + "source": source, + "target": target, + "type": "smoothstep", + "animated": is_animated, + "style": {"stroke": source_style.get("color", "#999")} + }) + edge_id += 1 + + return edges + + # Main execution + print("=== RENDER GRAPH PIPELINE ===") + print(f"Timestamp: {datetime.utcnow().isoformat()}") + + plan = load_architecture_plan("architecture_plan.json") + + # Extract data from 03-propose-architecture output structure + arch = plan.get("architecture", {}) + components = arch.get("components", []) + pattern = arch.get("pattern", "unknown") + topology = arch.get("topology", "") + scaling_strategy = arch.get("scaling_strategy", "vertical_scaling") + rationale = arch.get("rationale", "") + cost_tier = arch.get("estimated_cost_tier", "medium") + + # Get input metadata + inputs_meta = plan.get("inputs", {}) + source = plan.get("source", "unknown") # "oumi" or "heuristic" + + print(f"Source: {source}") + print(f"Pattern: {pattern}") + print(f"Components: {components}") + print(f"Scaling: {scaling_strategy}") + + if not components: + print("WARNING: No components found in architecture plan") + components = ["api_gateway", "lambda_functions", "dynamodb"] # Fallback + + # Create graph elements + nodes, normalized_components = create_nodes(components, pattern, scaling_strategy) + edges = create_edges(normalized_components) + + # Build final graph with full metadata + graph = { + "nodes": nodes, + "edges": edges, + "metadata": { + "pattern": pattern, + "topology": topology, + "scaling_strategy": scaling_strategy, + "rationale": rationale, + "estimated_cost_tier": cost_tier, + "component_count": len(nodes), + "edge_count": len(edges), + "source": source, + "cloud_provider": inputs_meta.get("cloud_provider", "aws"), + "service_count": inputs_meta.get("service_count", 0), + "primary_language": inputs_meta.get("primary_language", "unknown"), + "generated_at": datetime.utcnow().isoformat() + } + } + + with open("graph.json", "w") as f: + json.dump(graph, f, indent=2) + + print("=== OUTPUT ===") + print(json.dumps(graph, indent=2)) + +outputs: + - id: graph + type: FILE + value: "{{ outputs.working_dir.outputFiles['graph.json'] }}" diff --git a/orchestrator/kestra_pipelines/05-generate-iac.yaml b/orchestrator/kestra_pipelines/05-generate-iac.yaml new file mode 100644 index 0000000..d3aab95 --- /dev/null +++ b/orchestrator/kestra_pipelines/05-generate-iac.yaml @@ -0,0 +1,774 @@ +id: generate-iac +namespace: infoundry + +description: | + Generates production Terraform IaC from architecture graph. + Uses Kestra AI Agent for intelligent summarization and decision-making. + Falls back to heuristics when AI is unavailable. + +inputs: + - id: graph + type: FILE + required: true + description: Graph JSON from render-graph flow + + - id: cloud_provider + type: STRING + required: true + defaults: "aws" + description: Target cloud provider (aws, gcp, azure) + + - id: project_name + type: STRING + required: true + defaults: "infoundry" + description: Project name for resource naming + +tasks: + # ========================================================================== + # KESTRA AI AGENT: SUMMARIZE ARCHITECTURE DATA + # This satisfies: "use Kestra's built-in AI Agent to summarise data" + # ========================================================================== + - id: ai_summarize + type: io.kestra.plugin.ai.agent.AIAgent + allowFailure: true + provider: + type: io.kestra.plugin.ai.provider.OpenAI + baseUrl: "http://172.17.0.1:11434/v1" # Docker gateway to host Ollama + apiKey: "ollama" + modelName: qwen2.5:7b + systemMessage: | + You are an expert cloud architect. Analyze infrastructure architecture data + and provide a concise technical summary for IaC generation. + + Return ONLY valid JSON (no other text) with these fields: + - summary: string (2-3 sentence overview) + - pattern: string (architecture pattern name) + - component_count: number + - complexity: "low" or "medium" or "high" + - has_database: true/false + prompt: | + Analyze this architecture graph and return JSON summary: + {{ read(inputs.graph) }} + + # ========================================================================== + # KESTRA AI AGENT: MAKE DECISIONS BASED ON SUMMARIZED DATA + # This satisfies: "bonus credit if your agent can make decisions" + # ========================================================================== + - id: ai_decide + type: io.kestra.plugin.ai.agent.AIAgent + allowFailure: true + provider: + type: io.kestra.plugin.ai.provider.OpenAI + baseUrl: "http://172.17.0.1:11434/v1" # Docker gateway to host Ollama + apiKey: "ollama" + modelName: qwen2.5:7b + systemMessage: | + You are a DevOps engineer making IaC configuration decisions. + Based on the architecture summary, decide on optimal Terraform settings. + + Return ONLY valid JSON with these fields: + - enable_encryption: true/false + - multi_az: true/false + - use_autoscaling: true/false + - instance_tier: "micro" or "small" or "medium" or "large" + prompt: | + Based on this architecture, make IaC decisions. Return only JSON. + + Architecture: {{ outputs.ai_summarize.text ?? 'Simple 3-tier web app' }} + Cloud: {{ inputs.cloud_provider ?? 'aws' }} + + - id: working_dir + type: io.kestra.plugin.core.flow.WorkingDirectory + outputFiles: + - iac.zip + - iac_manifest.json + - ai_summary.json + - ai_decisions.json + tasks: + - id: download_graph + type: io.kestra.plugin.core.storage.LocalFiles + inputs: + graph.json: "{{ inputs.graph }}" + + - id: write_ai_outputs + type: io.kestra.plugin.scripts.shell.Script + env: + AI_SUMMARY: "{{ outputs.ai_summarize.textOutput ?? '{}' }}" + AI_DECISIONS: "{{ outputs.ai_decide.textOutput ?? '{}' }}" + script: | + echo "$AI_SUMMARY" > ai_summary_input.json + echo "$AI_DECISIONS" > ai_decisions_input.json + echo "=== AI FILES WRITTEN ===" + echo "ai_summary_input.json:" + head -c 200 ai_summary_input.json + echo "" + echo "ai_decisions_input.json:" + head -c 200 ai_decisions_input.json + + - id: generate + type: io.kestra.plugin.scripts.python.Script + env: + CLOUD_PROVIDER: "{{ inputs.cloud_provider ?? 'aws' }}" + PROJECT_NAME: "{{ inputs.project_name ?? 'infoundry' }}" + script: | + import json + import os + import zipfile + from pathlib import Path + from datetime import datetime + + cloud_provider = os.environ.get("CLOUD_PROVIDER", "aws") + project_name = os.environ.get("PROJECT_NAME", "infoundry") + output_dir = Path("iac_output") + output_dir.mkdir(exist_ok=True) + + # ========================================================================== + # PARSE AI OUTPUTS FROM FILES (or fallback to heuristics) + # ========================================================================== + ai_summary_raw = "" + ai_decisions_raw = "" + + # Read AI outputs from files (saved by Kestra LocalFiles) + try: + with open("ai_summary_input.json", "r") as f: + ai_summary_raw = f.read() + print("=== AI SUMMARY FILE LOADED ===") + print("Length:", len(ai_summary_raw)) + except FileNotFoundError: + print("ai_summary_input.json not found") + + try: + with open("ai_decisions_input.json", "r") as f: + ai_decisions_raw = f.read() + print("=== AI DECISIONS FILE LOADED ===") + print("Length:", len(ai_decisions_raw)) + except FileNotFoundError: + print("ai_decisions_input.json not found") + + use_heuristics = False + ai_summary = {} + ai_decisions = {} + + # Try to parse AI summary + if ai_summary_raw and len(ai_summary_raw.strip()) > 5: + try: + ai_summary = json.loads(ai_summary_raw) + if ai_summary.get("summary") or ai_summary.get("pattern"): + print("=== KESTRA AI AGENT SUMMARY ===") + print("Pattern:", ai_summary.get("pattern", "unknown")) + print("Complexity:", ai_summary.get("complexity", "unknown")) + else: + use_heuristics = True + except json.JSONDecodeError as e: + print("Failed to parse AI summary:", e) + use_heuristics = True + else: + use_heuristics = True + + # Try to parse AI decisions (strip markdown code fences if present) + if ai_decisions_raw and ai_decisions_raw.strip() not in ["", "{}"]: + # Strip markdown code fences (```json ... ```) + decisions_text = ai_decisions_raw.strip() + if decisions_text.startswith("```"): + lines = decisions_text.split("\n") + # Remove first line (```json) and last line (```) + lines = [l for l in lines if not l.strip().startswith("```")] + decisions_text = "\n".join(lines) + try: + ai_decisions = json.loads(decisions_text) + if "enable_encryption" in ai_decisions: + print("=== KESTRA AI AGENT DECISIONS ===") + print("Enable Encryption:", ai_decisions.get("enable_encryption", True)) + print("Multi-AZ:", ai_decisions.get("multi_az", False)) + else: + use_heuristics = True + except json.JSONDecodeError as e: + print("Failed to parse AI decisions:", e) + use_heuristics = True + else: + use_heuristics = True + + # ========================================================================== + # HEURISTIC FALLBACK + # ========================================================================== + if use_heuristics: + print("=== HEURISTIC MODE (AI Agent unavailable) ===") + + with open("graph.json") as f: + graph_data = json.load(f) + + nodes = graph_data.get("nodes", []) + metadata = graph_data.get("metadata", {}) + component_count = len(nodes) + component_types = [n.get("data", {}).get("type", n.get("id", "")) for n in nodes] + + # Determine complexity + if component_count <= 3: + complexity = "low" + instance_tier = "micro" + elif component_count <= 6: + complexity = "medium" + instance_tier = "small" + else: + complexity = "high" + instance_tier = "medium" + + has_database = any(t in component_types for t in ["rds", "aurora", "dynamodb"]) + has_cache = any(t in component_types for t in ["elasticache", "redis"]) + has_compute = any(t in component_types for t in ["ecs_cluster", "eks_cluster", "lambda_functions"]) + + enable_encryption = True + multi_az = complexity in ["medium", "high"] and has_database + use_autoscaling = has_compute and complexity != "low" + + ai_summary = { + "summary": "Heuristic analysis: " + str(component_count) + " components", + "pattern": metadata.get("pattern", "custom"), + "component_count": component_count, + "complexity": complexity, + "source": "heuristic" + } + + ai_decisions = { + "enable_encryption": enable_encryption, + "multi_az": multi_az, + "use_autoscaling": use_autoscaling, + "instance_tier": instance_tier, + "backup_retention_days": 7, + "source": "heuristic" + } + + print("Complexity:", complexity) + print("Instance Tier:", instance_tier) + + # Save outputs + with open("ai_summary.json", "w") as f: + json.dump(ai_summary, f, indent=2) + with open("ai_decisions.json", "w") as f: + json.dump(ai_decisions, f, indent=2) + + # Extract configurations + enable_encryption = ai_decisions.get("enable_encryption", True) + multi_az = ai_decisions.get("multi_az", False) + use_autoscaling = ai_decisions.get("use_autoscaling", False) + instance_tier = ai_decisions.get("instance_tier", "micro") + source_type = "heuristic" if use_heuristics else "kestra-ai-agent" + + # Instance sizes + SIZES = { + "micro": {"db": "db.t3.micro", "cache": "cache.t3.micro"}, + "small": {"db": "db.t3.small", "cache": "cache.t3.small"}, + "medium": {"db": "db.t3.medium", "cache": "cache.t3.medium"}, + "large": {"db": "db.t3.large", "cache": "cache.t3.large"}, + } + sizes = SIZES.get(instance_tier, SIZES["micro"]) + + # Load graph + with open("graph.json") as f: + graph = json.load(f) + + nodes = graph.get("nodes", []) + metadata = graph.get("metadata", {}) + pattern = metadata.get("pattern", "unknown") + + print("=== GENERATING TERRAFORM ===") + print("Pattern:", pattern) + print("Components:", len(nodes)) + + # Provider template + provider_tf = """terraform { + required_version = ">= 1.5.0" + required_providers { + aws = { + source = "hashicorp/aws" + version = "~> 5.0" + } + } + } + + provider "aws" { + region = var.region + default_tags { + tags = { + Project = var.project_name + Environment = var.environment + ManagedBy = "terraform" + CreatedBy = "infoundry" + } + } + } + """ + (output_dir / "provider.tf").write_text(provider_tf) + + # Variables template + variables_tf = '''variable "region" { + description = "AWS region" + type = string + default = "us-east-1" + } + + variable "project_name" { + description = "Project name" + type = string + default = "''' + project_name + '''" + } + + variable "environment" { + description = "Environment" + type = string + default = "dev" + } + + variable "vpc_id" { + description = "VPC ID" + type = string + default = "vpc-placeholder" + } + + variable "public_subnet_ids" { + description = "Public subnet IDs" + type = list(string) + default = ["subnet-public-1", "subnet-public-2"] + } + + variable "private_subnet_ids" { + description = "Private subnet IDs" + type = list(string) + default = ["subnet-private-1", "subnet-private-2"] + } + + variable "db_username" { + description = "Database username (set via TF_VAR_db_username or terraform.tfvars)" + type = string + sensitive = true + default = null + } + + variable "db_password" { + description = "Database password (auto-generated if not provided)" + type = string + sensitive = true + default = null + } + ''' + + # Add random password resource for secure credential generation + random_tf = ''' + # Generate secure random password if not provided + resource "random_password" "db_password" { + count = var.db_password == null ? 1 : 0 + length = 24 + special = true + override_special = "!#$%&*()-_=+[]{}<>:?" + } + + # Generate random username if not provided + resource "random_pet" "db_username" { + count = var.db_username == null ? 1 : 0 + length = 2 + separator = "_" + } + + # Local values for actual credentials + locals { + db_username = var.db_username != null ? var.db_username : random_pet.db_username[0].id + db_password = var.db_password != null ? var.db_password : random_password.db_password[0].result + } + ''' + (output_dir / "variables.tf").write_text(variables_tf) + (output_dir / "random.tf").write_text(random_tf) + + # Resource templates (using string concatenation to avoid Pebble conflicts) + TEMPLATES = {} + + TEMPLATES["api_gateway"] = '''resource "aws_api_gateway_rest_api" "NAME" { + name = "${var.project_name}-NAME" + description = "API Gateway managed by InFoundry" + endpoint_configuration { + types = ["REGIONAL"] + } + } + ''' + + TEMPLATES["alb"] = '''resource "aws_lb" "NAME" { + name = "${var.project_name}-NAME" + internal = false + load_balancer_type = "application" + security_groups = [aws_security_group.alb_sg.id] + subnets = var.public_subnet_ids + enable_deletion_protection = var.environment == "prod" + } + + resource "aws_security_group" "alb_sg" { + name = "${var.project_name}-alb-sg" + description = "ALB security group" + vpc_id = var.vpc_id + ingress { + from_port = 443 + to_port = 443 + protocol = "tcp" + cidr_blocks = ["0.0.0.0/0"] + } + ingress { + from_port = 80 + to_port = 80 + protocol = "tcp" + cidr_blocks = ["0.0.0.0/0"] + } + egress { + from_port = 0 + to_port = 0 + protocol = "-1" + cidr_blocks = ["0.0.0.0/0"] + } + } + ''' + + TEMPLATES["ecs_cluster"] = '''resource "aws_ecs_cluster" "NAME" { + name = "${var.project_name}-NAME" + setting { + name = "containerInsights" + value = "enabled" + } + } + + resource "aws_ecs_cluster_capacity_providers" "NAME_capacity" { + cluster_name = aws_ecs_cluster.NAME.name + capacity_providers = ["FARGATE", "FARGATE_SPOT"] + default_capacity_provider_strategy { + base = 1 + weight = 100 + capacity_provider = "FARGATE" + } + } + ''' + + TEMPLATES["eks_cluster"] = '''resource "aws_eks_cluster" "NAME" { + name = "${var.project_name}-NAME" + role_arn = aws_iam_role.eks_role.arn + version = "1.28" + vpc_config { + subnet_ids = var.private_subnet_ids + endpoint_private_access = true + endpoint_public_access = true + } + enabled_cluster_log_types = ["api", "audit"] + } + + resource "aws_iam_role" "eks_role" { + name = "${var.project_name}-eks-role" + assume_role_policy = jsonencode({ + Version = "2012-10-17" + Statement = [{ + Action = "sts:AssumeRole" + Effect = "Allow" + Principal = { Service = "eks.amazonaws.com" } + }] + }) + } + + resource "aws_iam_role_policy_attachment" "eks_policy" { + policy_arn = "arn:aws:iam::aws:policy/AmazonEKSClusterPolicy" + role = aws_iam_role.eks_role.name + } + ''' + + db_class = sizes["db"] + encryption_str = str(enable_encryption).lower() + multi_az_str = str(multi_az).lower() + backup_days = ai_decisions.get("backup_retention_days", 7) + + TEMPLATES["rds"] = '''resource "aws_db_instance" "NAME" { + identifier = "${var.project_name}-NAME" + engine = "postgres" + engine_version = "15.4" + instance_class = "''' + db_class + '''" + allocated_storage = 20 + max_allocated_storage = 100 + storage_type = "gp3" + storage_encrypted = ''' + encryption_str + ''' + db_name = replace(var.project_name, "-", "_") + username = local.db_username + password = local.db_password + vpc_security_group_ids = [aws_security_group.rds_sg.id] + db_subnet_group_name = aws_db_subnet_group.main.name + multi_az = ''' + multi_az_str + ''' + backup_retention_period = ''' + str(backup_days) + ''' + skip_final_snapshot = var.environment != "prod" + performance_insights_enabled = true + } + + resource "aws_security_group" "rds_sg" { + name = "${var.project_name}-rds-sg" + description = "RDS security group" + vpc_id = var.vpc_id + ingress { + from_port = 5432 + to_port = 5432 + protocol = "tcp" + security_groups = [aws_security_group.app_sg.id] + } + } + + resource "aws_db_subnet_group" "main" { + name = "${var.project_name}-db-subnet" + subnet_ids = var.private_subnet_ids + } + ''' + + TEMPLATES["dynamodb"] = '''resource "aws_dynamodb_table" "NAME" { + name = "${var.project_name}-NAME" + billing_mode = "PAY_PER_REQUEST" + hash_key = "id" + attribute { + name = "id" + type = "S" + } + point_in_time_recovery { + enabled = true + } + server_side_encryption { + enabled = ''' + encryption_str + ''' + } + } + ''' + + cache_class = sizes["cache"] + cache_nodes = "2" if multi_az else "1" + + TEMPLATES["elasticache"] = '''resource "aws_elasticache_cluster" "NAME" { + cluster_id = "${var.project_name}-NAME" + engine = "redis" + engine_version = "7.0" + node_type = "''' + cache_class + '''" + num_cache_nodes = ''' + cache_nodes + ''' + parameter_group_name = "default.redis7" + port = 6379 + security_group_ids = [aws_security_group.redis_sg.id] + subnet_group_name = aws_elasticache_subnet_group.main.name + } + + resource "aws_elasticache_subnet_group" "main" { + name = "${var.project_name}-redis-subnet" + subnet_ids = var.private_subnet_ids + } + + resource "aws_security_group" "redis_sg" { + name = "${var.project_name}-redis-sg" + vpc_id = var.vpc_id + ingress { + from_port = 6379 + to_port = 6379 + protocol = "tcp" + security_groups = [aws_security_group.app_sg.id] + } + } + ''' + + TEMPLATES["lambda_functions"] = '''resource "aws_lambda_function" "NAME" { + function_name = "${var.project_name}-NAME" + role = aws_iam_role.lambda_role.arn + handler = "main.handler" + runtime = "python3.11" + filename = "lambda.zip" + timeout = 30 + memory_size = 256 + environment { + variables = { + ENVIRONMENT = var.environment + } + } + tracing_config { + mode = "Active" + } + } + + resource "aws_iam_role" "lambda_role" { + name = "${var.project_name}-lambda-role" + assume_role_policy = jsonencode({ + Version = "2012-10-17" + Statement = [{ + Action = "sts:AssumeRole" + Effect = "Allow" + Principal = { Service = "lambda.amazonaws.com" } + }] + }) + } + + resource "aws_iam_role_policy_attachment" "lambda_basic" { + role = aws_iam_role.lambda_role.name + policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole" + } + ''' + + TEMPLATES["s3"] = '''resource "aws_s3_bucket" "NAME" { + bucket = "${var.project_name}-NAME-${var.environment}" + } + + resource "aws_s3_bucket_versioning" "NAME_versioning" { + bucket = aws_s3_bucket.NAME.id + versioning_configuration { + status = "Enabled" + } + } + + resource "aws_s3_bucket_server_side_encryption_configuration" "NAME_encryption" { + bucket = aws_s3_bucket.NAME.id + rule { + apply_server_side_encryption_by_default { + sse_algorithm = "AES256" + } + } + } + + resource "aws_s3_bucket_public_access_block" "NAME_public_access" { + bucket = aws_s3_bucket.NAME.id + block_public_acls = true + block_public_policy = true + ignore_public_acls = true + restrict_public_buckets = true + } + ''' + + TEMPLATES["sqs"] = '''resource "aws_sqs_queue" "NAME" { + name = "${var.project_name}-NAME" + visibility_timeout_seconds = 60 + sqs_managed_sse_enabled = true + } + ''' + + TEMPLATES["cdn"] = '''resource "aws_cloudfront_distribution" "NAME" { + enabled = true + is_ipv6_enabled = true + default_root_object = "index.html" + origin { + domain_name = "placeholder.s3.amazonaws.com" + origin_id = "S3-${var.project_name}" + } + default_cache_behavior { + allowed_methods = ["GET", "HEAD"] + cached_methods = ["GET", "HEAD"] + target_origin_id = "S3-${var.project_name}" + forwarded_values { + query_string = false + cookies { + forward = "none" + } + } + viewer_protocol_policy = "redirect-to-https" + } + restrictions { + geo_restriction { + restriction_type = "none" + } + } + viewer_certificate { + cloudfront_default_certificate = true + } + } + ''' + + # Generate main.tf + main_lines = [ + "# Generated by InFoundry with Kestra AI Agent", + "# Timestamp: " + datetime.utcnow().isoformat(), + "# Pattern: " + pattern, + "# Source: " + source_type, + "", + "# Application security group", + 'resource "aws_security_group" "app_sg" {', + ' name = "${var.project_name}-app-sg"', + ' description = "Application security group"', + ' vpc_id = var.vpc_id', + ' egress {', + ' from_port = 0', + ' to_port = 0', + ' protocol = "-1"', + ' cidr_blocks = ["0.0.0.0/0"]', + ' }', + '}', + "", + ] + + for node in nodes: + node_type = node.get("data", {}).get("type", node.get("id")) + node_id = node.get("id", "resource").replace("-", "_") + + if node_type in TEMPLATES: + resource_tf = TEMPLATES[node_type].replace("NAME", node_id) + main_lines.append(resource_tf) + main_lines.append("") + + (output_dir / "main.tf").write_text("\n".join(main_lines)) + + # Generate outputs.tf + outputs_lines = ["# Outputs", ""] + for node in nodes: + node_id = node.get("id", "").replace("-", "_") + node_type = node.get("data", {}).get("type", "") + + if node_type == "rds": + outputs_lines.append('output "' + node_id + '_endpoint" {') + outputs_lines.append(' value = aws_db_instance.' + node_id + '.endpoint') + outputs_lines.append('}') + elif node_type == "ecs_cluster": + outputs_lines.append('output "' + node_id + '_arn" {') + outputs_lines.append(' value = aws_ecs_cluster.' + node_id + '.arn') + outputs_lines.append('}') + elif node_type == "alb": + outputs_lines.append('output "' + node_id + '_dns" {') + outputs_lines.append(' value = aws_lb.' + node_id + '.dns_name') + outputs_lines.append('}') + outputs_lines.append("") + + (output_dir / "outputs.tf").write_text("\n".join(outputs_lines)) + + # Create ZIP + tf_files = list(output_dir.glob("*.tf")) + print("Generated", len(tf_files), "Terraform files") + + with zipfile.ZipFile("iac.zip", "w") as zf: + for f in output_dir.glob("*"): + zf.write(f, f.name) + + # Create manifest + manifest = { + "provider": cloud_provider, + "pattern": pattern, + "source": source_type, + "files": [f.name for f in output_dir.glob("*")], + "component_count": len(nodes), + "ai_summary": ai_summary, + "ai_decisions": { + "enable_encryption": enable_encryption, + "multi_az": multi_az, + "use_autoscaling": use_autoscaling, + "instance_tier": instance_tier + }, + "generated_at": datetime.utcnow().isoformat() + } + + with open("iac_manifest.json", "w") as f: + json.dump(manifest, f, indent=2) + + print(json.dumps(manifest, indent=2)) + +outputs: + - id: iac_bundle + type: FILE + value: "{{ outputs.working_dir.outputFiles['iac.zip'] }}" + + - id: iac_manifest + type: FILE + value: "{{ outputs.working_dir.outputFiles['iac_manifest.json'] }}" + + - id: ai_summary + type: FILE + value: "{{ outputs.working_dir.outputFiles['ai_summary.json'] }}" + description: AI-generated architecture summary (or heuristic fallback) + + - id: ai_decisions + type: FILE + value: "{{ outputs.working_dir.outputFiles['ai_decisions.json'] }}" + description: AI-made IaC decisions (or heuristic fallback) diff --git a/orchestrator/kestra_pipelines/06-validate-iac.yaml b/orchestrator/kestra_pipelines/06-validate-iac.yaml new file mode 100644 index 0000000..cb18f20 --- /dev/null +++ b/orchestrator/kestra_pipelines/06-validate-iac.yaml @@ -0,0 +1,121 @@ +id: validate-iac +namespace: infoundry + +description: Deploys IaC to test environment and runs smoke tests + +inputs: + - id: iac_bundle + type: FILE + required: true + description: ZIP file containing IaC files + +tasks: + - id: working_dir + type: io.kestra.plugin.core.flow.WorkingDirectory + outputFiles: + - deploy_result.json + tasks: + - id: download_iac + type: io.kestra.plugin.core.storage.LocalFiles + inputs: + iac.zip: "{{ inputs.iac_bundle }}" + + - id: deploy + type: io.kestra.plugin.scripts.python.Script + docker: + image: hashicorp/terraform:1.6 + entryPoint: [""] + beforeCommands: + - apk add --no-cache python3 + env: + ENVIRONMENT: "localstack" + # AWS credentials are optional - set in Kestra KV store if you want terraform plan to work + # AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION + script: | + import json + import sys + import os + import zipfile + import subprocess + from datetime import datetime + + environment = os.environ.get("ENVIRONMENT", "localstack") + + # Extract IaC + with zipfile.ZipFile("iac.zip", "r") as zf: + zf.extractall("iac_files") + + result = { + "environment": environment, + "started_at": datetime.utcnow().isoformat(), + "deploy_status": "pending", + "smoke_tests": {"passed": 0, "failed": 0, "tests": []}, + "success": False + } + + def run_cmd(cmd): + try: + r = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=120) + return r.returncode == 0, r.stdout + r.stderr + except subprocess.TimeoutExpired: + return False, "Command timeout after 120s" + except Exception as e: + return False, f"Command failed: {str(e)}" + + # Try Terraform init/plan + os.chdir("iac_files") + + # Run real Terraform commands (use -no-color for clean output) + tests = [] + + # Step 1: Terraform init + init_ok, init_out = run_cmd("terraform init -backend=false -input=false -no-color") + tests.append({"name": "terraform_init", "passed": init_ok, "output": init_out[:500]}) + + if not init_ok: + result["deploy_status"] = "init_failed" + result["deploy_output"] = init_out[:1000] + else: + # Step 2: Terraform validate + validate_ok, validate_out = run_cmd("terraform validate -json -no-color") + tests.append({"name": "terraform_validate", "passed": validate_ok, "output": validate_out[:500]}) + + # Step 3: Terraform fmt check (warning only, not blocking) + fmt_ok, fmt_out = run_cmd("terraform fmt -check -recursive") + tests.append({"name": "terraform_fmt", "passed": True, "output": fmt_out[:500] if not fmt_ok else "Format OK", "warning": not fmt_ok}) + + # Step 4: Terraform plan (warning only - requires real AWS creds) + plan_ok, plan_out = run_cmd("terraform plan -input=false -no-color 2>&1 || true") + # Ignore expected errors (missing vars, no credentials) + expected_errors = ["No value for required variable", "No valid credential sources", "failed to refresh cached credentials"] + plan_has_real_errors = "Error:" in plan_out and not any(e in plan_out for e in expected_errors) + tests.append({"name": "terraform_plan", "passed": not plan_has_real_errors, "output": plan_out[:500]}) + + # Only init + validate are required for success + core_passed = init_ok and validate_ok + result["deploy_status"] = "validated" if core_passed else "validation_failed" + result["deploy_output"] = plan_out[:1000] + result["success"] = core_passed + + # Record test results + result["smoke_tests"]["tests"] = tests + result["smoke_tests"]["passed"] = sum(1 for t in tests if t["passed"]) + result["smoke_tests"]["failed"] = sum(1 for t in tests if not t["passed"]) + + result["completed_at"] = datetime.utcnow().isoformat() + + os.chdir("..") + with open("deploy_result.json", "w") as f: + json.dump(result, f, indent=2) + print(json.dumps(result, indent=2)) + + # EXIT WITH ERROR IF VALIDATION FAILED - stops pipeline execution + if not result["success"]: + print("\n❌ VALIDATION FAILED - stopping pipeline") + sys.exit(1) + else: + print("\nβœ… VALIDATION PASSED - proceeding to next step") +outputs: + - id: deploy_result + type: FILE + value: "{{ outputs.working_dir.outputFiles['deploy_result.json'] }}" diff --git a/orchestrator/kestra_pipelines/07-create-pr.yaml b/orchestrator/kestra_pipelines/07-create-pr.yaml new file mode 100644 index 0000000..efc38a8 --- /dev/null +++ b/orchestrator/kestra_pipelines/07-create-pr.yaml @@ -0,0 +1,176 @@ +id: create-pr +namespace: infoundry + +description: Creates a GitHub Pull Request with generated IaC + +inputs: + - id: iac_bundle + type: FILE + required: true + description: ZIP file containing generated IaC + + - id: repository + type: STRING + required: true + defaults: "crypticsaiyan/infotest" + description: GitHub repository (owner/repo format) + + - id: base_branch + type: STRING + required: false + description: Base branch for PR (defaults to main) + + - id: target_folder + type: STRING + required: true + defaults: "infra" + description: Target folder in repo for Terraform files + + - id: labels + type: STRING + required: true + defaults: "infoundry,infrastructure,terraform" + description: Comma-separated labels to add to the PR + +tasks: + - id: working_dir + type: io.kestra.plugin.core.flow.WorkingDirectory + outputFiles: + - pr_result.json + tasks: + - id: download_iac + type: io.kestra.plugin.core.storage.LocalFiles + inputs: + iac.zip: "{{ inputs.iac_bundle }}" + + - id: create_pr + type: io.kestra.plugin.scripts.python.Script + timeout: PT5M + env: + GITHUB_TOKEN: "{{ kv('GITHUB_TOKEN') }}" + REPOSITORY: "{{ inputs.repository }}" + BASE_BRANCH: "{{ inputs.base_branch ?? 'main' }}" + TARGET_FOLDER: "{{ inputs.target_folder ?? 'infra' }}" + LABELS: "{{ inputs.labels ?? 'infoundry,infrastructure,terraform' }}" + script: | + import json + import os + import zipfile + import urllib.request + import urllib.error + from datetime import datetime + + github_token = os.environ.get("GITHUB_TOKEN", "") + repository = os.environ.get("REPOSITORY", "") + base_branch = os.environ.get("BASE_BRANCH", "main") + target_folder = os.environ.get("TARGET_FOLDER", "infra") + labels_str = os.environ.get("LABELS", "infoundry,infrastructure,terraform") + labels = [l.strip() for l in labels_str.split(",") if l.strip()] + + timestamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S") + branch_name = f"infoundry/iac-{timestamp}" + + # Extract IaC files + with zipfile.ZipFile("iac.zip", "r") as zf: + zf.extractall("iac_files") + + files = list(os.listdir("iac_files")) + print(f"Extracted files: {files}") + + def github_api(method, endpoint, data=None): + url = f"https://api.github.com/repos/{repository}{endpoint}" + headers = { + "Authorization": f"token {github_token}", + "Accept": "application/vnd.github.v3+json", + "Content-Type": "application/json" + } + req = urllib.request.Request(url, method=method, headers=headers) + if data: + req.data = json.dumps(data).encode() + try: + with urllib.request.urlopen(req, timeout=30) as resp: + return json.load(resp) + except urllib.error.HTTPError as e: + print(f"GitHub API error: {e.code} {e.read().decode()}") + return None + + result = { + "repository": repository, + "branch": branch_name, + "base_branch": base_branch, + "files": files, + "labels": labels, + "pr_url": None, + "pr_number": None, + "status": "pending" + } + + if not github_token: + print("No GITHUB_TOKEN configured - skipping PR creation") + result["status"] = "skipped" + result["message"] = "No GitHub token configured" + else: + # Get base branch SHA + ref = github_api("GET", f"/git/refs/heads/{base_branch}") + if ref: + base_sha = ref["object"]["sha"] + + # Create new branch + branch_data = {"ref": f"refs/heads/{branch_name}", "sha": base_sha} + branch_result = github_api("POST", "/git/refs", branch_data) + + if branch_result: + # Upload files to new branch + for filename in files: + filepath = f"iac_files/{filename}" + with open(filepath, "r") as f: + content = f.read() + + import base64 + file_data = { + "message": f"Add {filename} via InFoundry", + "content": base64.b64encode(content.encode()).decode(), + "branch": branch_name + } + github_api("PUT", f"/contents/{target_folder}/{filename}", file_data) + + # Create PR + pr_data = { + "title": f"[InFoundry] Infrastructure Update {timestamp}", + "head": branch_name, + "base": base_branch, + "body": "This PR was automatically generated by InFoundry Architect." + } + pr = github_api("POST", "/pulls", pr_data) + + if pr: + result["pr_url"] = pr.get("html_url") + result["pr_number"] = pr.get("number") + result["status"] = "created" + print(f"PR created: {result['pr_url']}") + + # Add labels to PR + if labels: + label_result = github_api("POST", f"/issues/{pr['number']}/labels", {"labels": labels}) + if label_result: + print(f"Labels added: {labels}") + else: + print("Warning: Failed to add labels") + else: + result["status"] = "failed" + result["message"] = "Failed to create PR" + else: + result["status"] = "failed" + result["message"] = "Failed to create branch" + else: + result["status"] = "failed" + result["message"] = "Failed to get base branch" + + with open("pr_result.json", "w") as f: + json.dump(result, f, indent=2) + print(json.dumps(result, indent=2)) + +outputs: + - id: pr_result + type: FILE + value: "{{ outputs.working_dir.outputFiles['pr_result.json'] }}" diff --git a/orchestrator/kestra_pipelines/08-validate-pr.yaml b/orchestrator/kestra_pipelines/08-validate-pr.yaml new file mode 100644 index 0000000..898dcc1 --- /dev/null +++ b/orchestrator/kestra_pipelines/08-validate-pr.yaml @@ -0,0 +1,118 @@ +id: validate-pr +namespace: infoundry + +description: Polls GitHub for PR check statuses and CodeRabbit reviews + +inputs: + - id: pr_result + type: FILE + required: true + description: PR result JSON from create-pr flow + + - id: repository + type: STRING + required: true + defaults: "crypticsaiyan/infotest" + description: GitHub repository (owner/repo format) + +tasks: + - id: working_dir + type: io.kestra.plugin.core.flow.WorkingDirectory + outputFiles: + - validation_result.json + tasks: + - id: download_pr + type: io.kestra.plugin.core.storage.LocalFiles + inputs: + pr_result.json: "{{ inputs.pr_result }}" + + - id: validate + type: io.kestra.plugin.scripts.python.Script + env: + GITHUB_TOKEN: "{{ kv('GITHUB_TOKEN') }}" + REPOSITORY: "{{ inputs.repository }}" + script: | + import json + import os + import time + import urllib.request + import urllib.error + + github_token = os.environ.get("GITHUB_TOKEN", "") + repository = os.environ.get("REPOSITORY", "") + + with open("pr_result.json") as f: + pr_result = json.load(f) + + pr_number = pr_result.get("pr_number") + + result = { + "pr_number": pr_number, + "repository": repository, + "checks": [], + "reviews": [], + "status": "pending", + "passed": False + } + + if not pr_number: + result["status"] = "skipped" + result["message"] = "No PR number provided" + elif not github_token: + result["status"] = "skipped" + result["message"] = "No GitHub token configured" + else: + def github_api(endpoint): + url = f"https://api.github.com/repos/{repository}{endpoint}" + headers = { + "Authorization": f"token {github_token}", + "Accept": "application/vnd.github.v3+json" + } + req = urllib.request.Request(url, headers=headers) + try: + with urllib.request.urlopen(req, timeout=30) as resp: + return json.load(resp) + except: + return None + + # Poll for checks (up to 5 minutes) + max_attempts = 30 + for attempt in range(max_attempts): + pr = github_api(f"/pulls/{pr_number}") + if pr: + head_sha = pr.get("head", {}).get("sha") + if head_sha: + checks = github_api(f"/commits/{head_sha}/check-runs") + if checks: + result["checks"] = [ + {"name": c["name"], "status": c["status"], "conclusion": c.get("conclusion")} + for c in checks.get("check_runs", []) + ] + + all_complete = all(c["status"] == "completed" for c in result["checks"]) + all_passed = all(c.get("conclusion") in ["success", "skipped"] for c in result["checks"]) + + if all_complete: + result["status"] = "completed" + result["passed"] = all_passed + break + + if attempt < max_attempts - 1: + time.sleep(10) + + # Get reviews + reviews = github_api(f"/pulls/{pr_number}/reviews") + if reviews: + result["reviews"] = [ + {"user": r.get("user", {}).get("login"), "state": r.get("state")} + for r in reviews + ] + + with open("validation_result.json", "w") as f: + json.dump(result, f, indent=2) + print(json.dumps(result, indent=2)) + +outputs: + - id: validation_result + type: FILE + value: "{{ outputs.working_dir.outputFiles['validation_result.json'] }}" diff --git a/orchestrator/kestra_pipelines/09-evaluate.yaml b/orchestrator/kestra_pipelines/09-evaluate.yaml new file mode 100644 index 0000000..e6746d1 --- /dev/null +++ b/orchestrator/kestra_pipelines/09-evaluate.yaml @@ -0,0 +1,136 @@ +id: evaluate +namespace: infoundry + +description: | + Evaluates IaC deployment results using Kestra AI Agent. + Provides intelligent feedback and recommendations. + +inputs: + - id: deploy_result + type: FILE + required: true + description: Deploy result JSON from validate-iac flow + + - id: architecture_plan + type: FILE + required: false + description: Architecture plan for evaluation context + +tasks: + # Kestra AI Agent for intelligent evaluation + - id: ai_evaluate + type: io.kestra.plugin.ai.agent.AIAgent + allowFailure: true + provider: + type: io.kestra.plugin.ai.provider.OpenAI + baseUrl: "http://172.17.0.1:11434/v1" + apiKey: "ollama" + modelName: qwen2.5:7b + systemMessage: | + You are a cloud infrastructure quality evaluator. Analyze Terraform + validation results and provide actionable feedback. + + Return ONLY valid JSON with these fields: + - score: number from 0.0 to 1.0 + - recommendation: "proceed", "review", or "reject" + - feedback: brief 1-2 sentence explanation + - improvements: list of 2-3 suggested improvements + prompt: | + Evaluate this Terraform validation result and provide quality assessment: + {{ read(inputs.deploy_result) }} + + - id: working_dir + type: io.kestra.plugin.core.flow.WorkingDirectory + outputFiles: + - evaluation_result.json + tasks: + - id: download_inputs + type: io.kestra.plugin.core.storage.LocalFiles + inputs: + deploy_result.json: "{{ inputs.deploy_result }}" + + - id: write_ai_output + type: io.kestra.plugin.scripts.shell.Script + env: + AI_EVALUATION: "{{ outputs.ai_evaluate.textOutput ?? '{}' }}" + script: | + echo "$AI_EVALUATION" > ai_evaluation_input.json + echo "=== AI EVALUATION ===" + cat ai_evaluation_input.json + + - id: process_evaluation + type: io.kestra.plugin.scripts.python.Script + script: | + import json + from datetime import datetime + + # Load deployment result + with open("deploy_result.json") as f: + deploy = json.load(f) + + # Try to load AI evaluation + ai_eval = {} + use_heuristic = False + + try: + with open("ai_evaluation_input.json") as f: + content = f.read().strip() + # Strip markdown fences if present + if content.startswith("```"): + lines = content.split("\n") + lines = [l for l in lines if not l.strip().startswith("```")] + content = "\n".join(lines) + if content and content != "{}": + ai_eval = json.loads(content) + print("=== KESTRA AI EVALUATION ===") + print("Score:", ai_eval.get("score", "N/A")) + print("Recommendation:", ai_eval.get("recommendation", "N/A")) + except (FileNotFoundError, json.JSONDecodeError) as e: + print("AI evaluation not available, using heuristics:", e) + use_heuristic = True + + # Fallback to heuristic scoring if AI unavailable + if not ai_eval.get("score"): + use_heuristic = True + smoke = deploy.get("smoke_tests", {}) + total_tests = smoke.get("passed", 0) + smoke.get("failed", 0) + test_score = smoke.get("passed", 0) / max(total_tests, 1) + deploy_success = 1.0 if deploy.get("success") else 0.0 + score = (deploy_success * 0.5) + (test_score * 0.4) + (0.1 if deploy.get("deploy_status") == "validated" else 0) + + if score > 0.7: + recommendation = "proceed" + elif score > 0.4: + recommendation = "review" + else: + recommendation = "reject" + + ai_eval = { + "score": round(score, 3), + "recommendation": recommendation, + "feedback": "Heuristic evaluation based on test results", + "improvements": ["Consider adding more validation checks"] + } + + result = { + "source": "heuristic" if use_heuristic else "kestra-ai-agent", + "score": ai_eval.get("score", 0), + "recommendation": ai_eval.get("recommendation", "review"), + "feedback": ai_eval.get("feedback", ""), + "improvements": ai_eval.get("improvements", []), + "metrics": { + "tests_passed": deploy.get("smoke_tests", {}).get("passed", 0), + "tests_failed": deploy.get("smoke_tests", {}).get("failed", 0), + "deploy_status": deploy.get("deploy_status", "unknown") + }, + "evaluated_at": datetime.utcnow().isoformat() + } + + with open("evaluation_result.json", "w") as f: + json.dump(result, f, indent=2) + print(json.dumps(result, indent=2)) + +outputs: + - id: evaluation_result + type: FILE + value: "{{ outputs.working_dir.outputFiles['evaluation_result.json'] }}" diff --git a/orchestrator/kestra_pipelines/README.md b/orchestrator/kestra_pipelines/README.md new file mode 100644 index 0000000..e790bc3 --- /dev/null +++ b/orchestrator/kestra_pipelines/README.md @@ -0,0 +1,88 @@ +# Kestra Orchestration Pipelines + +This directory contains the Kestra pipelines that power the InFoundry Architect agent. Each pipeline corresponds to a step in the architecture generation and deployment workflow. + +## Overview + +Kestra orchestrates the entire lifecycle: +1. **Ingest**: Analyze repository and telemetry. +2. **Propose**: Generate architecture plan using Oumi AI. +3. **Render**: Visual graph generation. +4. **Generate**: Create Terraform IaC. +5. **Validate**: Verify IaC correctness. +6. **PR**: Create GitHub Pull Request. +7. **Evaluate**: Deploy and score the architecture. + +## AI Agent Capabilities + +InFoundry uses **Kestra's built-in AI Agent** to summarize data from other systems and make intelligent decisions: + +1. **Data Summarization**: The `ai_summarize` task in the `05-generate-iac` pipeline analyzes the complex graph data and produces a concise technical summary. +2. **Autonomous Decision Making**: The `ai_decide` task consumes this summary to make critical architecture decisions (e.g., enabling encryption, selecting instance tiers, configuring auto-scaling) **without human intervention**. + +This demonstrates the power of Kestra's AI capabilities to not just process data, but to strictly reasoning about it and driving the workflow logic. + +## Pipelines + +| Pipeline | Description | Inputs | Outputs | +|----------|-------------|--------|---------| +| `00-end-to-end` | Master pipeline chaining all steps | `repo_url`, `branch`, `repository`, `cloud_provider`, `project_name`, `target_folder`, `skip_pr`, `skip_validation` | All artifacts | +| `01-ingest-repo` | Analyzes repo to detect services | `repo_url`, `branch` | `service_profile.json` | +| `02-ingest-telemetry` | Fetches mock telemetry metrics | `services` | `telemetry_summary.json` | +| `03-propose-architecture` | Generates architecture plan via Oumi | `service_profile`, `telemetry_summary`, `use_oumi`, `cloud_provider`, `oumi_server_url` | `architecture_plan.json` | +| `04-render-graph` | Builds React Flow graph JSON | `architecture_plan` | `graph.json` | +| `05-generate-iac` | Generates Terraform bundle | `graph`, `cloud_provider`, `project_name` | `iac_bundle` (zip), `iac_manifest.json`, `ai_summary.json`, `ai_decisions.json` | +| `06-validate-iac` | Validates Terraform code | `iac_bundle` | `deploy_result.json` | +| `07-create-pr` | Creates GitHub PR with changes | `iac_bundle`, `repository`, `base_branch`, `target_folder`, `labels` | `pr_result.json` | +| `08-validate-pr` | Monitors PR status and checks | `pr_result`, `repository` | `validation_result.json` | +| `09-evaluate` | Computes reward score for RL | `deploy_result` | `evaluation_result.json` | + +## Usage + +### Prerequisites + +- Kestra server running (Docker or standalone) +- Oumi server running (for AI proposals) +- GitHub Personal Access Token (PAT) configured +- AWS/Cloud credentials configured + +### Deployment + +Upload all pipelines to Kestra: + +```bash +cd orchestrator/kestra_pipelines +for f in *.yaml; do + curl -X POST http://localhost:8080/api/v1/flows \ + -H "Content-Type: application/x-yaml" \ + --data-binary @"$f" +done +``` + +### Configuration + +Ensure the following secrets are set in Kestra: +- `GITHUB_TOKEN`: For PR creation and cloning private repos. +- `AWS_ACCESS_KEY_ID`: For deployment steps. +- `AWS_SECRET_ACCESS_KEY`: For deployment steps. + +### Running a Pipeline + +You can trigger the end-to-end flow via API: + +```bash +curl -X POST http://localhost:8080/api/v1/executions \ + -H "Content-Type: application/json" \ + -d '{ + "namespace": "infoundry", + "flowId": "end-to-end", + "inputs": { + "repo_url": "https://github.com/crypticsaiyan/infotest", + "branch": "main", + "repository": "crypticsaiyan/infotest", + "cloud_provider": "aws", + "project_name": "infoundry-demo", + "skip_pr": false + } + }' +``` diff --git a/orchestrator/kestra_pipelines/collect-and-summarize.yaml b/orchestrator/kestra_pipelines/collect-and-summarize.yaml deleted file mode 100644 index 3659437..0000000 --- a/orchestrator/kestra_pipelines/collect-and-summarize.yaml +++ /dev/null @@ -1,26 +0,0 @@ -id: collect-and-summarize -tasks: - - id: fetch-metrics - type: http - url: file://./examples/telemetry/metrics.json - - id: summarize - type: script - script: | - #!/usr/bin/env python3 - import json - metrics = json.load(open('examples/telemetry/metrics.json')) - summary = {} - for svc, vals in metrics.items(): - p95 = sorted(vals['latencies'])[int(0.95*len(vals['latencies']))] - p50 = sorted(vals['latencies'])[int(0.5*len(vals['latencies']))] - summary[svc] = { - 'p50': p50, - 'p95': p95, - 'error_rate': sum(vals['errors'])/len(vals['errors']), - 'cost': vals.get('cost', 0), - } - print(json.dumps(summary)) - - id: emit - type: http - url: http://localhost:8000/api/summaries - diff --git a/orchestrator/kestra_pipelines/namespace.yaml b/orchestrator/kestra_pipelines/namespace.yaml new file mode 100644 index 0000000..2c29bb8 --- /dev/null +++ b/orchestrator/kestra_pipelines/namespace.yaml @@ -0,0 +1,80 @@ +id: namespace-config +namespace: infoundry + +description: | + Namespace configuration for InFoundry Architect. + Contains shared variables, secrets references, and plugin configurations. + +variables: + # AI Provider Configuration (Ollama) + OLLAMA_ENDPOINT: http://172.17.0.1:11434/v1 + AI_MODEL: qwen2.5:7b + + # Default configurations + DEFAULT_CLOUD_PROVIDER: aws + DEFAULT_IAC_FORMAT: terraform + DEFAULT_TEST_ENVIRONMENT: localstack + DEFAULT_REPOSITORY: crypticsaiyan/infotest + DEFAULT_TARGET_FOLDER: infra + + # Timeout configurations + TASK_TIMEOUT_MINUTES: 30 + PR_VALIDATION_TIMEOUT_MINUTES: 30 + + # Retry configurations + DEFAULT_MAX_RETRIES: 3 + DEFAULT_RETRY_INTERVAL: PT10S + +pluginDefaults: + # Default Python script configuration + - type: io.kestra.plugin.scripts.python.Script + values: + docker: + image: python:3.11-slim + beforeCommands: + - pip install --quiet requests + + # Terraform validation configuration + - type: io.kestra.plugin.scripts.python.Script + forced: + docker: + image: hashicorp/terraform:1.6 + entryPoint: [""] + beforeCommands: + - apk add --no-cache python3 + + # Default Shell script configuration + - type: io.kestra.plugin.scripts.shell.Script + values: + docker: + image: alpine:latest + +concurrency: + limit: 5 + behavior: QUEUE + +# Note: Secrets/KV should be configured in Kestra UI +# Available KV keys (configure these in Kestra β†’ Settings β†’ Key-Value Store): +# - GITHUB_TOKEN: GitHub Personal Access Token for PR operations +# - AWS_ACCESS_KEY_ID: AWS credentials for terraform plan (optional) +# - AWS_SECRET_ACCESS_KEY: AWS credentials for terraform plan (optional) +# - AWS_REGION: AWS region (default: us-east-1) + +# Pipeline overview: +# 00-full-iac-pipeline: Complete orchestrated flow +# 01-ingest-repo: Parse GitHub repository +# 02-ingest-telemetry: Collect telemetry data +# 03-propose-architecture: AI-based architecture proposal (Oumi) +# 04-render-graph: Generate architecture graph +# 05-generate-iac: AI-powered Terraform generation (Kestra AI Agent + Ollama) +# 06-validate-iac: Terraform init, validate, fmt, plan +# 07-create-pr: Create GitHub PR with generated IaC +# 08-validate-pr: Monitor PR checks and CodeRabbit reviews +# 09-evaluate: AI-powered evaluation of deployment results + +labels: + project: infoundry + team: platform + environment: development + +disabled: false diff --git a/orchestrator/oumi_integration.py b/orchestrator/oumi_integration.py deleted file mode 100644 index 9cd50b3..0000000 --- a/orchestrator/oumi_integration.py +++ /dev/null @@ -1,26 +0,0 @@ -""" -Stub for Oumi integration. -Replace the placeholders with real Oumi SDK/CLI calls when available. -""" -from typing import List, Dict - - -def rank_actions(summary: Dict, top_k: int = 3) -> List[str]: - """ - Given a telemetry summary, return ranked action strings. - In production, call the tuned Oumi model here. - """ - # Placeholder heuristic - actions = [] - for svc, vals in summary.items(): - if vals.get("p95", 0) > 400: - actions.append(f"add_hpa(service={svc},min=2,max=6)") - if vals.get("cost", 0) > 50: - actions.append(f"downsize_instance(service={svc},to=t3.small)") - return actions[:top_k] - - -if __name__ == "__main__": - demo_summary = {"auth": {"p95": 420, "cost": 60}, "payments": {"p95": 210, "cost": 35}} - print(rank_actions(demo_summary)) - diff --git a/orchestrator/repo_analyzer/scan.py b/orchestrator/repo_analyzer/scan.py deleted file mode 100644 index f475bf5..0000000 --- a/orchestrator/repo_analyzer/scan.py +++ /dev/null @@ -1,36 +0,0 @@ -""" -Lightweight repo analyzer stub. -- Detects service folders with Dockerfiles. -- Emits a simple service profile JSON for downstream steps. -""" -from pathlib import Path -import json - - -def detect_services(root: Path) -> dict: - services = {} - for svc_dir in (root / "services").glob("*"): - dockerfile = svc_dir / "Dockerfile" - if dockerfile.exists(): - services[svc_dir.name] = { - "path": str(svc_dir), - "dockerfile": str(dockerfile), - "language": "python", - "framework": "fastapi", - "ports": [8000, 8001], - } - return services - - -def write_service_profile(root: Path) -> Path: - profile = {"services": detect_services(root)} - out_path = root / "service_profile.json" - out_path.write_text(json.dumps(profile, indent=2)) - return out_path - - -if __name__ == "__main__": - project_root = Path(__file__).resolve().parents[2] - output = write_service_profile(project_root) - print(f"service profile written to {output}") - diff --git a/oumi/.gitignore b/oumi/.gitignore new file mode 100644 index 0000000..39f511b --- /dev/null +++ b/oumi/.gitignore @@ -0,0 +1,5 @@ +trained_model/ +*.safetensors +*.pt +*.bin +venv/ \ No newline at end of file diff --git a/oumi/InFoundry_Cloud_Training.ipynb b/oumi/InFoundry_Cloud_Training.ipynb new file mode 100644 index 0000000..bc3bfbb --- /dev/null +++ b/oumi/InFoundry_Cloud_Training.ipynb @@ -0,0 +1,4719 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "e17b459ca44541b99fb2f5e027f35549": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_47214d8efd5b47f59d41cdcf73af784b", + "IPY_MODEL_a0d5a41ba85544faa4203604bdd36def", + "IPY_MODEL_d91de1410d814415993862fabb112ea1" + ], + "layout": "IPY_MODEL_8430e1101863452c9c351b526c55d156" + } + }, + "47214d8efd5b47f59d41cdcf73af784b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ecafd17d15ef4272886372d57fe59772", + "placeholder": "​", + "style": "IPY_MODEL_d80b53f940fc4185b9e4f7110ad1e0ac", + "value": "config.json: 100%" + } + }, + "a0d5a41ba85544faa4203604bdd36def": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6f03a70dead044abb8d68d90924bc1de", + "max": 660, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_05134369a9954c719b111adf38f70984", + "value": 660 + } + }, + "d91de1410d814415993862fabb112ea1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ebbeaa35db7d47b785a4b3c77bc4701d", + "placeholder": "​", + "style": "IPY_MODEL_81522af75b36485ca50cd4f823be7e1f", + "value": " 660/660 [00:00<00:00, 77.3kB/s]" + } + }, + "8430e1101863452c9c351b526c55d156": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ecafd17d15ef4272886372d57fe59772": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d80b53f940fc4185b9e4f7110ad1e0ac": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6f03a70dead044abb8d68d90924bc1de": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "05134369a9954c719b111adf38f70984": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ebbeaa35db7d47b785a4b3c77bc4701d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "81522af75b36485ca50cd4f823be7e1f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "196ccdfca80642f9a9af22cdfaf96677": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_28471a590fb443baa08287d1d50d809d", + "IPY_MODEL_43d5d912675b4486b760ad57747b4dac", + "IPY_MODEL_688d010ec56e4adcba1b72c187b30521" + ], + "layout": "IPY_MODEL_26a39e57bbcb4408bd862bbf28135f06" + } + }, + "28471a590fb443baa08287d1d50d809d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5774c781aee6470b83b48df93b6dd5ac", + "placeholder": "​", + "style": "IPY_MODEL_1d37274a9a7e4774990f12751ee85e41", + "value": "tokenizer_config.json: " + } + }, + "43d5d912675b4486b760ad57747b4dac": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_455fea62d27a411ea9715bf77de55552", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1e176193720c4440a630c8c6d6d37574", + "value": 1 + } + }, + "688d010ec56e4adcba1b72c187b30521": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_87886767501e45f88567fe6c18853499", + "placeholder": "​", + "style": "IPY_MODEL_1e5a525cd6dd46dbb5799001fa4d0085", + "value": " 7.30k/? [00:00<00:00, 631kB/s]" + } + }, + "26a39e57bbcb4408bd862bbf28135f06": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5774c781aee6470b83b48df93b6dd5ac": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1d37274a9a7e4774990f12751ee85e41": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "455fea62d27a411ea9715bf77de55552": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "1e176193720c4440a630c8c6d6d37574": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "87886767501e45f88567fe6c18853499": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1e5a525cd6dd46dbb5799001fa4d0085": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e60a6c98b61f4e38b185f3d932a20ba1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6c9693904ade42bc96244ce3f3bef34b", + "IPY_MODEL_7a3f535f8dd149bfbb99cca9494db026", + "IPY_MODEL_58846b24e702493198a0c46ed8f5ba75" + ], + "layout": "IPY_MODEL_72524b77db8944a7a4a781c00a68dae7" + } + }, + "6c9693904ade42bc96244ce3f3bef34b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e6dd1d58a04248b78c49c0b3c94fef51", + "placeholder": "​", + "style": "IPY_MODEL_5fb28f3e16384ddca3b865526463e49c", + "value": "vocab.json: " + } + }, + "7a3f535f8dd149bfbb99cca9494db026": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0fc3a3d7ea784d318c7d064adbb543e5", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_950cca24f73941b4aeaa1b4be0302f72", + "value": 1 + } + }, + "58846b24e702493198a0c46ed8f5ba75": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4db8fbca9743489eb2862c2c804e2ae5", + "placeholder": "​", + "style": "IPY_MODEL_d0e67edc90f94b1e8f6a376bcfac3944", + "value": " 2.78M/? [00:00<00:00, 52.6MB/s]" + } + }, + "72524b77db8944a7a4a781c00a68dae7": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e6dd1d58a04248b78c49c0b3c94fef51": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5fb28f3e16384ddca3b865526463e49c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0fc3a3d7ea784d318c7d064adbb543e5": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "950cca24f73941b4aeaa1b4be0302f72": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4db8fbca9743489eb2862c2c804e2ae5": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d0e67edc90f94b1e8f6a376bcfac3944": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fe1b3c5d484144f782ab7e7afdf01763": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3db89c0eb2ec41b2aaad1f529f32a5db", + "IPY_MODEL_a18b6ac518ad4a698be8cd6eb7abb3fc", + "IPY_MODEL_17acedd4523a4ad490fedc393194f280" + ], + "layout": "IPY_MODEL_54261000001047e299d508e9de1f7ae6" + } + }, + "3db89c0eb2ec41b2aaad1f529f32a5db": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ea031d58c02e4a758de92865383dbab4", + "placeholder": "​", + "style": "IPY_MODEL_bc9c40622ff14d1399aaae01133d6d84", + "value": "merges.txt: " + } + }, + "a18b6ac518ad4a698be8cd6eb7abb3fc": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b46c070fa9984dfda31a33941b28cab7", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d2836bc5b353440daa26071c325d0116", + "value": 1 + } + }, + "17acedd4523a4ad490fedc393194f280": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_10945f347214454492014b7a6528b971", + "placeholder": "​", + "style": "IPY_MODEL_6e9c79d33279443d91749df184c18a18", + "value": " 1.67M/? [00:00<00:00, 52.5MB/s]" + } + }, + "54261000001047e299d508e9de1f7ae6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ea031d58c02e4a758de92865383dbab4": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bc9c40622ff14d1399aaae01133d6d84": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b46c070fa9984dfda31a33941b28cab7": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "d2836bc5b353440daa26071c325d0116": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "10945f347214454492014b7a6528b971": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6e9c79d33279443d91749df184c18a18": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bddd06c4708642dab45a279efb450338": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c7c57d0a9dd34237a277e5dc3c995cc8", + "IPY_MODEL_6c95a99bc1f84532a436a6fa9c02b918", + "IPY_MODEL_990e6257b335436980e1408f93bcb08c" + ], + "layout": "IPY_MODEL_a12f70d9d554408b8ffa07900a426ff2" + } + }, + "c7c57d0a9dd34237a277e5dc3c995cc8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8ab755ca43c9403b885602848bf4d1df", + "placeholder": "​", + "style": "IPY_MODEL_af8cd544f4e24934b3158a0a3991424a", + "value": "tokenizer.json: " + } + }, + "6c95a99bc1f84532a436a6fa9c02b918": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9c93c9ea94694f35bd5bba72f9637be6", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3466e7fd8bee491d9c1e7bfb5ac931e6", + "value": 1 + } + }, + "990e6257b335436980e1408f93bcb08c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0d086bbf196e4d52a33a80fb10432f29", + "placeholder": "​", + "style": "IPY_MODEL_b8a13a1271fb4e0f82feccce897b7157", + "value": " 7.03M/? [00:00<00:00, 104MB/s]" + } + }, + "a12f70d9d554408b8ffa07900a426ff2": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8ab755ca43c9403b885602848bf4d1df": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "af8cd544f4e24934b3158a0a3991424a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9c93c9ea94694f35bd5bba72f9637be6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "3466e7fd8bee491d9c1e7bfb5ac931e6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0d086bbf196e4d52a33a80fb10432f29": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b8a13a1271fb4e0f82feccce897b7157": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "44b86f4b039c439cae12bbaf52494ec6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_15504882ded84c94917b8d78215482d0", + "IPY_MODEL_f4bfbe619be849fabcda734c81cd3512", + "IPY_MODEL_b7945bbc39864ca7873eef773f21412c" + ], + "layout": "IPY_MODEL_d46a2242ea1641ad8b54d36ad743c4b9" + } + }, + "15504882ded84c94917b8d78215482d0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_179fa7c1b4584059b36eb5cebc43810a", + "placeholder": "​", + "style": "IPY_MODEL_a3bcc05bc8ed406eb58dfb6f056c4da3", + "value": "Generating train split: " + } + }, + "f4bfbe619be849fabcda734c81cd3512": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f0deded782694cd5813bc647a70fb257", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_dbe90c5b0a4b40af834b70c23cd8f271", + "value": 1 + } + }, + "b7945bbc39864ca7873eef773f21412c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_17ee42c4bebd4bc78b215a22936ac018", + "placeholder": "​", + "style": "IPY_MODEL_ec525072f51a4daaa2514bac787f4b68", + "value": " 9/0 [00:00<00:00, 105.60 examples/s]" + } + }, + "d46a2242ea1641ad8b54d36ad743c4b9": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "179fa7c1b4584059b36eb5cebc43810a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a3bcc05bc8ed406eb58dfb6f056c4da3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f0deded782694cd5813bc647a70fb257": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "dbe90c5b0a4b40af834b70c23cd8f271": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "17ee42c4bebd4bc78b215a22936ac018": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ec525072f51a4daaa2514bac787f4b68": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c01dbb5780144ca1802cb98d8de9efe6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_981368edbdc84ef894a28497bc56113a", + "IPY_MODEL_932de8084aba4a8c875ef6294a8d31b6", + "IPY_MODEL_249a174fc87045b6814bcf66997a37d4" + ], + "layout": "IPY_MODEL_4369a364cc1b43a6b88714614b62ad86" + } + }, + "981368edbdc84ef894a28497bc56113a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6f290f716e3b43e3bc4b63fba3550f4a", + "placeholder": "​", + "style": "IPY_MODEL_2d8b22b663434ac78431d0f43bbc6808", + "value": "Generating train split: " + } + }, + "932de8084aba4a8c875ef6294a8d31b6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9f85c02a5f2b4fbaa75fd3a654fd2780", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_dc50f8801d63492f89aeb6421360d89c", + "value": 1 + } + }, + "249a174fc87045b6814bcf66997a37d4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2531235bbbb64519a8e771cbca8f2a07", + "placeholder": "​", + "style": "IPY_MODEL_3fed80a4381d4db58a0b86cf44cefcfd", + "value": " 500/0 [00:01<00:00, 492.74 examples/s]" + } + }, + "4369a364cc1b43a6b88714614b62ad86": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6f290f716e3b43e3bc4b63fba3550f4a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2d8b22b663434ac78431d0f43bbc6808": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9f85c02a5f2b4fbaa75fd3a654fd2780": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "dc50f8801d63492f89aeb6421360d89c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2531235bbbb64519a8e771cbca8f2a07": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3fed80a4381d4db58a0b86cf44cefcfd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a87ff382495a4aa5bf50a099614cf8dd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_83a8a627b9594614a981f1fda6e267dd", + "IPY_MODEL_d3eb2891e0c5444d96a2b090f1b44309", + "IPY_MODEL_4b1f43348d2b4a34b5c195b2af74f23b" + ], + "layout": "IPY_MODEL_bd576e5068754e829436b73cd89b52af" + } + }, + "83a8a627b9594614a981f1fda6e267dd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ec7125c9e59444508a395af3b0e481fb", + "placeholder": "​", + "style": "IPY_MODEL_76a14788c83e4dafab4df456d6a8894a", + "value": "model.safetensors: 100%" + } + }, + "d3eb2891e0c5444d96a2b090f1b44309": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0f5cefe29ccd4bd48ed1ac3fe75cb127", + "max": 3087467144, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9762ec5bc6e645b98a1be25fca099b25", + "value": 3087467144 + } + }, + "4b1f43348d2b4a34b5c195b2af74f23b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6e256931061a4afb9cded340d38e98a2", + "placeholder": "​", + "style": "IPY_MODEL_58bf07467ad34ae987b91ee5d55af69d", + "value": " 3.09G/3.09G [00:27<00:00, 235MB/s]" + } + }, + "bd576e5068754e829436b73cd89b52af": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ec7125c9e59444508a395af3b0e481fb": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "76a14788c83e4dafab4df456d6a8894a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0f5cefe29ccd4bd48ed1ac3fe75cb127": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9762ec5bc6e645b98a1be25fca099b25": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6e256931061a4afb9cded340d38e98a2": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "58bf07467ad34ae987b91ee5d55af69d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "02b5cc491a4b4822bcc847da5ed94dc9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f59063135e8d4bb3b36fa785b6187bfb", + "IPY_MODEL_c83fd073214d47c0891f8c1df20235a2", + "IPY_MODEL_d2f9e486c49249c4a64d8d7431247da0" + ], + "layout": "IPY_MODEL_a474faf62bf44f57a1f6c89d7823293d" + } + }, + "f59063135e8d4bb3b36fa785b6187bfb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_018dd9ad501a46c1ab93144bb0f5fa7e", + "placeholder": "​", + "style": "IPY_MODEL_7d384cc04486487da8371651b07b3754", + "value": "generation_config.json: 100%" + } + }, + "c83fd073214d47c0891f8c1df20235a2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fefca726134041afaa0843520496fe1a", + "max": 242, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9f0b1e0f81504fb8b70eb493d44eb9bb", + "value": 242 + } + }, + "d2f9e486c49249c4a64d8d7431247da0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_38f85c1b84094c2d87255d0a6d1af2dd", + "placeholder": "​", + "style": "IPY_MODEL_c557cf30f2da4192850ad676769c628b", + "value": " 242/242 [00:00<00:00, 26.5kB/s]" + } + }, + "a474faf62bf44f57a1f6c89d7823293d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "018dd9ad501a46c1ab93144bb0f5fa7e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7d384cc04486487da8371651b07b3754": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fefca726134041afaa0843520496fe1a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9f0b1e0f81504fb8b70eb493d44eb9bb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "38f85c1b84094c2d87255d0a6d1af2dd": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c557cf30f2da4192850ad676769c628b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "## πŸ—οΈ InFoundry Architect - Cloud Training\n", + "\n", + "Train a larger model (1.5B or 3B) on Google Colab's free T4 GPU.\n", + "\n", + "**Requirements:**\n", + "- Enable GPU: Runtime β†’ Change runtime type β†’ T4 GPU\n", + "- Upload `generated_training_data.jsonl` when prompted" + ], + "metadata": { + "id": "header" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Step 1: Install Dependencies" + ], + "metadata": { + "id": "step1" + } + }, + { + "cell_type": "code", + "source": [ + "# Install Oumi and dependencies\n", + "!pip install oumi[gpu]\n", + "print(\"βœ… Dependencies installed\")" + ], + "metadata": { + "id": "install", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "96a96117-99c9-4652-be60-97a563f14a96" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: oumi[gpu] in /usr/local/lib/python3.12/dist-packages (0.5.0)\n", + "Requirement already satisfied: accelerate<2.0,>=1.10.0 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (1.12.0)\n", + "Requirement already satisfied: aiohttp<3.16,>=3.12 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (3.13.2)\n", + "Requirement already satisfied: aiofiles<25,>=24.1.0 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (24.1.0)\n", + "Requirement already satisfied: aioresponses<0.8,>=0.7 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.7.8)\n", + "Requirement already satisfied: backoff<2.3,>=2.2.1 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (2.2.1)\n", + "Requirement already satisfied: click<8.3.0 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (8.1.8)\n", + "Requirement already satisfied: datasets<3.3,>=3.2 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (3.2.0)\n", + "Requirement already satisfied: hdrhistogram<0.11,>=0.10 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.10.3)\n", + "Requirement already satisfied: jsonlines in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (4.0.0)\n", + "Requirement already satisfied: lm_eval<0.5.0,>=0.4 in /usr/local/lib/python3.12/dist-packages (from lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (0.4.9.2)\n", + "Requirement already satisfied: mlflow>=3.1 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (3.7.0)\n", + "Requirement already satisfied: numpy<2.4,>=1.26 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (1.26.4)\n", + "Requirement already satisfied: omegaconf==2.4.0.dev3 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (2.4.0.dev3)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (25.0)\n", + "Requirement already satisfied: pandas<3,>=2.3 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (2.3.3)\n", + "Requirement already satisfied: peft<0.18,>=0.17 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.17.1)\n", + "Requirement already satisfied: pexpect<4.10,>=4.9 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (4.9.0)\n", + "Requirement already satisfied: pillow<11.4,>=11.3 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (11.3.0)\n", + "Requirement already satisfied: protobuf>=6.32 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (6.33.2)\n", + "Requirement already satisfied: pydantic<2.12,>=2.11 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (2.11.10)\n", + "Requirement already satisfied: responses<0.26,>=0.25 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.25.8)\n", + "Requirement already satisfied: safetensors<0.7,>=0.6 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.6.2)\n", + "Requirement already satisfied: skypilot<0.11,>=0.10.2 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.10.5)\n", + "Requirement already satisfied: tensorboard<2.21,>=2.20 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (2.20.0)\n", + "Requirement already satisfied: torch<2.9.0,>=2.6 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (2.8.0)\n", + "Requirement already satisfied: torchao<0.13,>=0.12 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.12.0)\n", + "Requirement already satisfied: torchdata<0.10.0,>=0.9 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.9.0)\n", + "Requirement already satisfied: torchvision<0.24,>=0.21 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.23.0)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (4.67.1)\n", + "Requirement already satisfied: transformers<4.58,>=4.57 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (4.57.3)\n", + "Requirement already satisfied: trl<0.26,>=0.25 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.25.1)\n", + "Requirement already satisfied: typer in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.20.0)\n", + "Requirement already satisfied: typing_extensions in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (4.15.0)\n", + "Requirement already satisfied: uvicorn<0.36.0 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.35.0)\n", + "Requirement already satisfied: wandb<0.22,>=0.21 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.21.4)\n", + "Requirement already satisfied: liger-kernel<0.7,>=0.6 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.6.4)\n", + "Requirement already satisfied: nvidia-ml-py<13.581,>=13.580 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (13.580.82)\n", + "Requirement already satisfied: bitsandbytes<0.48,>=0.47 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.47.0)\n", + "Requirement already satisfied: verl<0.6,>=0.5 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.5.0)\n", + "Requirement already satisfied: vllm<0.11,>=0.10 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.10.2)\n", + "Requirement already satisfied: deepspeed<0.18.0,>=0.17.0 in /usr/local/lib/python3.12/dist-packages (from oumi[gpu]) (0.17.6)\n", + "Requirement already satisfied: PyYAML>=5.1.0 in /usr/local/lib/python3.12/dist-packages (from omegaconf==2.4.0.dev3->oumi[gpu]) (6.0.3)\n", + "Requirement already satisfied: psutil in /usr/local/lib/python3.12/dist-packages (from accelerate<2.0,>=1.10.0->oumi[gpu]) (5.9.5)\n", + "Requirement already satisfied: huggingface_hub>=0.21.0 in /usr/local/lib/python3.12/dist-packages (from accelerate<2.0,>=1.10.0->oumi[gpu]) (0.36.0)\n", + "Requirement already satisfied: aiohappyeyeballs>=2.5.0 in /usr/local/lib/python3.12/dist-packages (from aiohttp<3.16,>=3.12->oumi[gpu]) (2.6.1)\n", + "Requirement already satisfied: aiosignal>=1.4.0 in /usr/local/lib/python3.12/dist-packages (from aiohttp<3.16,>=3.12->oumi[gpu]) (1.4.0)\n", + "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.12/dist-packages (from aiohttp<3.16,>=3.12->oumi[gpu]) (25.4.0)\n", + "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.12/dist-packages (from aiohttp<3.16,>=3.12->oumi[gpu]) (1.8.0)\n", + "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.12/dist-packages (from aiohttp<3.16,>=3.12->oumi[gpu]) (6.7.0)\n", + "Requirement already satisfied: propcache>=0.2.0 in /usr/local/lib/python3.12/dist-packages (from aiohttp<3.16,>=3.12->oumi[gpu]) (0.4.1)\n", + "Requirement already satisfied: yarl<2.0,>=1.17.0 in /usr/local/lib/python3.12/dist-packages (from aiohttp<3.16,>=3.12->oumi[gpu]) (1.22.0)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from datasets<3.3,>=3.2->oumi[gpu]) (3.20.0)\n", + "Requirement already satisfied: pyarrow>=15.0.0 in /usr/local/lib/python3.12/dist-packages (from datasets<3.3,>=3.2->oumi[gpu]) (22.0.0)\n", + "Requirement already satisfied: dill<0.3.9,>=0.3.0 in /usr/local/lib/python3.12/dist-packages (from datasets<3.3,>=3.2->oumi[gpu]) (0.3.8)\n", + "Requirement already satisfied: requests>=2.32.2 in /usr/local/lib/python3.12/dist-packages (from datasets<3.3,>=3.2->oumi[gpu]) (2.32.4)\n", + "Requirement already satisfied: xxhash in /usr/local/lib/python3.12/dist-packages (from datasets<3.3,>=3.2->oumi[gpu]) (3.6.0)\n", + "Requirement already satisfied: multiprocess<0.70.17 in /usr/local/lib/python3.12/dist-packages (from datasets<3.3,>=3.2->oumi[gpu]) (0.70.16)\n", + "Requirement already satisfied: fsspec<=2024.9.0,>=2023.1.0 in /usr/local/lib/python3.12/dist-packages (from fsspec[http]<=2024.9.0,>=2023.1.0->datasets<3.3,>=3.2->oumi[gpu]) (2024.9.0)\n", + "Requirement already satisfied: einops in /usr/local/lib/python3.12/dist-packages (from deepspeed<0.18.0,>=0.17.0->oumi[gpu]) (0.8.1)\n", + "Requirement already satisfied: hjson in /usr/local/lib/python3.12/dist-packages (from deepspeed<0.18.0,>=0.17.0->oumi[gpu]) (3.1.0)\n", + "Requirement already satisfied: msgpack in /usr/local/lib/python3.12/dist-packages (from deepspeed<0.18.0,>=0.17.0->oumi[gpu]) (1.1.2)\n", + "Requirement already satisfied: ninja in /usr/local/lib/python3.12/dist-packages (from deepspeed<0.18.0,>=0.17.0->oumi[gpu]) (1.13.0)\n", + "Requirement already satisfied: py-cpuinfo in /usr/local/lib/python3.12/dist-packages (from deepspeed<0.18.0,>=0.17.0->oumi[gpu]) (9.0.0)\n", + "Requirement already satisfied: pbr>=1.4 in /usr/local/lib/python3.12/dist-packages (from hdrhistogram<0.11,>=0.10->oumi[gpu]) (7.0.3)\n", + "Requirement already satisfied: triton>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from liger-kernel<0.7,>=0.6->oumi[gpu]) (3.4.0)\n", + "Requirement already satisfied: evaluate in /usr/local/lib/python3.12/dist-packages (from lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (0.4.6)\n", + "Requirement already satisfied: numexpr in /usr/local/lib/python3.12/dist-packages (from lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (2.14.1)\n", + "Requirement already satisfied: pybind11>=2.6.2 in /usr/local/lib/python3.12/dist-packages (from lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (3.0.1)\n", + "Requirement already satisfied: pytablewriter in /usr/local/lib/python3.12/dist-packages (from lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (1.2.1)\n", + "Requirement already satisfied: rouge-score>=0.0.4 in /usr/local/lib/python3.12/dist-packages (from lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (0.1.2)\n", + "Requirement already satisfied: sacrebleu>=1.5.0 in /usr/local/lib/python3.12/dist-packages (from lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (2.5.1)\n", + "Requirement already satisfied: scikit-learn>=0.24.1 in /usr/local/lib/python3.12/dist-packages (from lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (1.6.1)\n", + "Requirement already satisfied: sqlitedict in /usr/local/lib/python3.12/dist-packages (from lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (2.1.0)\n", + "Requirement already satisfied: tqdm-multiprocess in /usr/local/lib/python3.12/dist-packages (from lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (0.0.11)\n", + "Requirement already satisfied: zstandard in /usr/local/lib/python3.12/dist-packages (from lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (0.25.0)\n", + "Requirement already satisfied: word2number in /usr/local/lib/python3.12/dist-packages (from lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (1.1)\n", + "Requirement already satisfied: more_itertools in /usr/local/lib/python3.12/dist-packages (from lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (10.8.0)\n", + "Requirement already satisfied: mlflow-skinny==3.7.0 in /usr/local/lib/python3.12/dist-packages (from mlflow>=3.1->oumi[gpu]) (3.7.0)\n", + "Requirement already satisfied: mlflow-tracing==3.7.0 in /usr/local/lib/python3.12/dist-packages (from mlflow>=3.1->oumi[gpu]) (3.7.0)\n", + "Requirement already satisfied: Flask-CORS<7 in /usr/local/lib/python3.12/dist-packages (from mlflow>=3.1->oumi[gpu]) (6.0.1)\n", + "Requirement already satisfied: Flask<4 in /usr/local/lib/python3.12/dist-packages (from mlflow>=3.1->oumi[gpu]) (3.1.2)\n", + "Requirement already satisfied: alembic!=1.10.0,<2 in /usr/local/lib/python3.12/dist-packages (from mlflow>=3.1->oumi[gpu]) (1.17.2)\n", + "Requirement already satisfied: cryptography<47,>=43.0.0 in /usr/local/lib/python3.12/dist-packages (from mlflow>=3.1->oumi[gpu]) (43.0.3)\n", + "Requirement already satisfied: docker<8,>=4.0.0 in /usr/local/lib/python3.12/dist-packages (from mlflow>=3.1->oumi[gpu]) (7.1.0)\n", + "Requirement already satisfied: graphene<4 in /usr/local/lib/python3.12/dist-packages (from mlflow>=3.1->oumi[gpu]) (3.4.3)\n", + "Requirement already satisfied: gunicorn<24 in /usr/local/lib/python3.12/dist-packages (from mlflow>=3.1->oumi[gpu]) (23.0.0)\n", + "Requirement already satisfied: huey<3,>=2.5.0 in /usr/local/lib/python3.12/dist-packages (from mlflow>=3.1->oumi[gpu]) (2.5.5)\n", + "Requirement already satisfied: matplotlib<4 in /usr/local/lib/python3.12/dist-packages (from mlflow>=3.1->oumi[gpu]) (3.10.0)\n", + "Requirement already satisfied: scipy<2 in /usr/local/lib/python3.12/dist-packages (from mlflow>=3.1->oumi[gpu]) (1.16.3)\n", + "Requirement already satisfied: sqlalchemy<3,>=1.4.0 in /usr/local/lib/python3.12/dist-packages (from mlflow>=3.1->oumi[gpu]) (2.0.44)\n", + "Requirement already satisfied: cachetools<7,>=5.0.0 in /usr/local/lib/python3.12/dist-packages (from mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (6.2.2)\n", + "Requirement already satisfied: cloudpickle<4 in /usr/local/lib/python3.12/dist-packages (from mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (3.1.2)\n", + "Requirement already satisfied: databricks-sdk<1,>=0.20.0 in /usr/local/lib/python3.12/dist-packages (from mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (0.74.0)\n", + "Requirement already satisfied: fastapi<1 in /usr/local/lib/python3.12/dist-packages (from mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (0.118.3)\n", + "Requirement already satisfied: gitpython<4,>=3.1.9 in /usr/local/lib/python3.12/dist-packages (from mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (3.1.45)\n", + "Requirement already satisfied: importlib_metadata!=4.7.0,<9,>=3.7.0 in /usr/local/lib/python3.12/dist-packages (from mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (8.7.0)\n", + "Requirement already satisfied: opentelemetry-api<3,>=1.9.0 in /usr/local/lib/python3.12/dist-packages (from mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (1.37.0)\n", + "Requirement already satisfied: opentelemetry-proto<3,>=1.9.0 in /usr/local/lib/python3.12/dist-packages (from mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (1.37.0)\n", + "Requirement already satisfied: opentelemetry-sdk<3,>=1.9.0 in /usr/local/lib/python3.12/dist-packages (from mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (1.37.0)\n", + "Requirement already satisfied: python-dotenv<2,>=0.19.0 in /usr/local/lib/python3.12/dist-packages (from mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (1.2.1)\n", + "Requirement already satisfied: sqlparse<1,>=0.4.0 in /usr/local/lib/python3.12/dist-packages (from mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (0.5.4)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.12/dist-packages (from pandas<3,>=2.3->oumi[gpu]) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/dist-packages (from pandas<3,>=2.3->oumi[gpu]) (2025.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas<3,>=2.3->oumi[gpu]) (2025.2)\n", + "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.12/dist-packages (from pexpect<4.10,>=4.9->oumi[gpu]) (0.7.0)\n", + "Requirement already satisfied: annotated-types>=0.6.0 in /usr/local/lib/python3.12/dist-packages (from pydantic<2.12,>=2.11->oumi[gpu]) (0.7.0)\n", + "Requirement already satisfied: pydantic-core==2.33.2 in /usr/local/lib/python3.12/dist-packages (from pydantic<2.12,>=2.11->oumi[gpu]) (2.33.2)\n", + "Requirement already satisfied: typing-inspection>=0.4.0 in /usr/local/lib/python3.12/dist-packages (from pydantic<2.12,>=2.11->oumi[gpu]) (0.4.2)\n", + "Requirement already satisfied: urllib3<3.0,>=1.25.10 in /usr/local/lib/python3.12/dist-packages (from responses<0.26,>=0.25->oumi[gpu]) (2.5.0)\n", + "Requirement already satisfied: wheel<0.46.0 in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (0.45.1)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (79.0.1)\n", + "Requirement already satisfied: pip in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (24.1.2)\n", + "Requirement already satisfied: colorama in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (0.4.6)\n", + "Requirement already satisfied: jinja2>=3.0 in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (3.1.6)\n", + "Requirement already satisfied: jsonschema in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (4.25.1)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (3.6.1)\n", + "Requirement already satisfied: pendulum in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (3.1.0)\n", + "Requirement already satisfied: PrettyTable>=2.0.0 in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (3.17.0)\n", + "Requirement already satisfied: rich in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (13.9.4)\n", + "Requirement already satisfied: tabulate in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (0.9.0)\n", + "Requirement already satisfied: pulp in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (3.3.0)\n", + "Requirement already satisfied: ijson in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (3.4.0.post0)\n", + "Requirement already satisfied: orjson in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (3.11.5)\n", + "Requirement already satisfied: python-multipart in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (0.0.20)\n", + "Requirement already satisfied: httpx in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (0.28.1)\n", + "Requirement already satisfied: setproctitle in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (1.3.7)\n", + "Requirement already satisfied: psycopg2-binary in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (2.9.11)\n", + "Requirement already satisfied: aiosqlite in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (0.21.0)\n", + "Requirement already satisfied: asyncpg in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (0.31.0)\n", + "Requirement already satisfied: casbin in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (1.43.0)\n", + "Requirement already satisfied: sqlalchemy_adapter in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (1.9.0)\n", + "Requirement already satisfied: prometheus_client>=0.8.0 in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (0.23.1)\n", + "Requirement already satisfied: passlib in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (1.7.4)\n", + "Requirement already satisfied: bcrypt==4.0.1 in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (4.0.1)\n", + "Requirement already satisfied: pyjwt in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (2.10.1)\n", + "Requirement already satisfied: types-paramiko in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (4.0.0.20250822)\n", + "Requirement already satisfied: anyio in /usr/local/lib/python3.12/dist-packages (from skypilot<0.11,>=0.10.2->oumi[gpu]) (4.12.0)\n", + "Requirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.12/dist-packages (from tensorboard<2.21,>=2.20->oumi[gpu]) (1.4.0)\n", + "Requirement already satisfied: grpcio>=1.48.2 in /usr/local/lib/python3.12/dist-packages (from tensorboard<2.21,>=2.20->oumi[gpu]) (1.76.0)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.12/dist-packages (from tensorboard<2.21,>=2.20->oumi[gpu]) (3.10)\n", + "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.12/dist-packages (from tensorboard<2.21,>=2.20->oumi[gpu]) (0.7.2)\n", + "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from tensorboard<2.21,>=2.20->oumi[gpu]) (3.1.4)\n", + "Requirement already satisfied: sympy>=1.13.3 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (1.14.0)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.8.93 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (12.8.93)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (12.8.90)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (12.8.90)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==9.10.2.21 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (9.10.2.21)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.8.4.1 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (12.8.4.1)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.3.3.83 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (11.3.3.83)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.9.90 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (10.3.9.90)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.7.3.90 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (11.7.3.90)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.5.8.93 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (12.5.8.93)\n", + "Requirement already satisfied: nvidia-cusparselt-cu12==0.7.1 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (0.7.1)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.27.3 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (2.27.3)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (12.8.90)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12==12.8.93 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (12.8.93)\n", + "Requirement already satisfied: nvidia-cufile-cu12==1.13.1.3 in /usr/local/lib/python3.12/dist-packages (from torch<2.9.0,>=2.6->oumi[gpu]) (1.13.1.3)\n", + "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.12/dist-packages (from transformers<4.58,>=4.57->oumi[gpu]) (2025.11.3)\n", + "Requirement already satisfied: tokenizers<=0.23.0,>=0.22.0 in /usr/local/lib/python3.12/dist-packages (from transformers<4.58,>=4.57->oumi[gpu]) (0.22.1)\n", + "Requirement already satisfied: h11>=0.8 in /usr/local/lib/python3.12/dist-packages (from uvicorn<0.36.0->oumi[gpu]) (0.16.0)\n", + "Requirement already satisfied: codetiming in /usr/local/lib/python3.12/dist-packages (from verl<0.6,>=0.5->oumi[gpu]) (1.4.0)\n", + "Requirement already satisfied: hydra-core in /usr/local/lib/python3.12/dist-packages (from verl<0.6,>=0.5->oumi[gpu]) (1.3.0)\n", + "Requirement already satisfied: pylatexenc in /usr/local/lib/python3.12/dist-packages (from verl<0.6,>=0.5->oumi[gpu]) (2.10)\n", + "Requirement already satisfied: ray>=2.41.0 in /usr/local/lib/python3.12/dist-packages (from ray[default]>=2.41.0->verl<0.6,>=0.5->oumi[gpu]) (2.52.1)\n", + "Requirement already satisfied: tensordict!=0.9.0,<=0.9.1,>=0.8.0 in /usr/local/lib/python3.12/dist-packages (from verl<0.6,>=0.5->oumi[gpu]) (0.9.1)\n", + "Requirement already satisfied: sentencepiece in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (0.2.1)\n", + "Requirement already satisfied: blake3 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (1.0.8)\n", + "Requirement already satisfied: openai>=1.99.1 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (2.9.0)\n", + "Requirement already satisfied: prometheus-fastapi-instrumentator>=7.0.0 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (7.1.0)\n", + "Requirement already satisfied: tiktoken>=0.6.0 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (0.12.0)\n", + "Requirement already satisfied: lm-format-enforcer==0.11.3 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (0.11.3)\n", + "Requirement already satisfied: llguidance<0.8.0,>=0.7.11 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (0.7.30)\n", + "Requirement already satisfied: outlines_core==0.2.11 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (0.2.11)\n", + "Requirement already satisfied: diskcache==5.6.3 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (5.6.3)\n", + "Requirement already satisfied: lark==1.2.2 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (1.2.2)\n", + "Requirement already satisfied: xgrammar==0.1.23 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (0.1.23)\n", + "Requirement already satisfied: partial-json-parser in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (0.2.1.1.post7)\n", + "Requirement already satisfied: pyzmq>=25.0.0 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (26.2.1)\n", + "Requirement already satisfied: msgspec in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (0.20.0)\n", + "Requirement already satisfied: gguf>=0.13.0 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (0.17.1)\n", + "Requirement already satisfied: mistral_common>=1.8.2 in /usr/local/lib/python3.12/dist-packages (from mistral_common[audio,image]>=1.8.2->vllm<0.11,>=0.10->oumi[gpu]) (1.8.6)\n", + "Requirement already satisfied: opencv-python-headless>=4.11.0 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (4.11.0.86)\n", + "Requirement already satisfied: six>=1.16.0 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (1.17.0)\n", + "Requirement already satisfied: compressed-tensors==0.11.0 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (0.11.0)\n", + "Requirement already satisfied: depyf==0.19.0 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (0.19.0)\n", + "Requirement already satisfied: watchfiles in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (1.1.1)\n", + "Requirement already satisfied: python-json-logger in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (4.0.0)\n", + "Requirement already satisfied: pybase64 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (1.4.3)\n", + "Requirement already satisfied: cbor2 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (5.7.1)\n", + "Requirement already satisfied: openai-harmony>=0.0.3 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (0.0.8)\n", + "Requirement already satisfied: numba==0.61.2 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (0.61.2)\n", + "Requirement already satisfied: torchaudio==2.8.0 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (2.8.0)\n", + "Requirement already satisfied: xformers==0.0.32.post1 in /usr/local/lib/python3.12/dist-packages (from vllm<0.11,>=0.10->oumi[gpu]) (0.0.32.post1)\n", + "Requirement already satisfied: frozendict in /usr/local/lib/python3.12/dist-packages (from compressed-tensors==0.11.0->vllm<0.11,>=0.10->oumi[gpu]) (2.4.7)\n", + "Requirement already satisfied: astor in /usr/local/lib/python3.12/dist-packages (from depyf==0.19.0->vllm<0.11,>=0.10->oumi[gpu]) (0.8.1)\n", + "Requirement already satisfied: interegular>=0.3.2 in /usr/local/lib/python3.12/dist-packages (from lm-format-enforcer==0.11.3->vllm<0.11,>=0.10->oumi[gpu]) (0.3.3)\n", + "Requirement already satisfied: llvmlite<0.45,>=0.44.0dev0 in /usr/local/lib/python3.12/dist-packages (from numba==0.61.2->vllm<0.11,>=0.10->oumi[gpu]) (0.44.0)\n", + "Requirement already satisfied: platformdirs in /usr/local/lib/python3.12/dist-packages (from wandb<0.22,>=0.21->oumi[gpu]) (4.5.1)\n", + "Requirement already satisfied: sentry-sdk>=2.0.0 in /usr/local/lib/python3.12/dist-packages (from wandb<0.22,>=0.21->oumi[gpu]) (2.47.0)\n", + "Requirement already satisfied: shellingham>=1.3.0 in /usr/local/lib/python3.12/dist-packages (from typer->oumi[gpu]) (1.5.4)\n", + "Requirement already satisfied: Mako in /usr/local/lib/python3.12/dist-packages (from alembic!=1.10.0,<2->mlflow>=3.1->oumi[gpu]) (1.3.10)\n", + "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.12/dist-packages (from cryptography<47,>=43.0.0->mlflow>=3.1->oumi[gpu]) (2.0.0)\n", + "Requirement already satisfied: starlette<0.49.0,>=0.40.0 in /usr/local/lib/python3.12/dist-packages (from fastapi<1->mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (0.48.0)\n", + "Requirement already satisfied: fastapi-cli>=0.0.8 in /usr/local/lib/python3.12/dist-packages (from fastapi-cli[standard]>=0.0.8; extra == \"standard\"->fastapi[standard]>=0.115.0->vllm<0.11,>=0.10->oumi[gpu]) (0.0.16)\n", + "Requirement already satisfied: email-validator>=2.0.0 in /usr/local/lib/python3.12/dist-packages (from fastapi[standard]>=0.115.0->vllm<0.11,>=0.10->oumi[gpu]) (2.3.0)\n", + "Requirement already satisfied: blinker>=1.9.0 in /usr/local/lib/python3.12/dist-packages (from Flask<4->mlflow>=3.1->oumi[gpu]) (1.9.0)\n", + "Requirement already satisfied: itsdangerous>=2.2.0 in /usr/local/lib/python3.12/dist-packages (from Flask<4->mlflow>=3.1->oumi[gpu]) (2.2.0)\n", + "Requirement already satisfied: markupsafe>=2.1.1 in /usr/local/lib/python3.12/dist-packages (from Flask<4->mlflow>=3.1->oumi[gpu]) (3.0.3)\n", + "Requirement already satisfied: gitdb<5,>=4.0.1 in /usr/local/lib/python3.12/dist-packages (from gitpython<4,>=3.1.9->mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (4.0.12)\n", + "Requirement already satisfied: graphql-core<3.3,>=3.1 in /usr/local/lib/python3.12/dist-packages (from graphene<4->mlflow>=3.1->oumi[gpu]) (3.2.7)\n", + "Requirement already satisfied: graphql-relay<3.3,>=3.1 in /usr/local/lib/python3.12/dist-packages (from graphene<4->mlflow>=3.1->oumi[gpu]) (3.2.0)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.12/dist-packages (from httpx->skypilot<0.11,>=0.10.2->oumi[gpu]) (2025.11.12)\n", + "Requirement already satisfied: httpcore==1.* in /usr/local/lib/python3.12/dist-packages (from httpx->skypilot<0.11,>=0.10.2->oumi[gpu]) (1.0.9)\n", + "Requirement already satisfied: idna in /usr/local/lib/python3.12/dist-packages (from httpx->skypilot<0.11,>=0.10.2->oumi[gpu]) (3.11)\n", + "Requirement already satisfied: hf-xet<2.0.0,>=1.1.3 in /usr/local/lib/python3.12/dist-packages (from huggingface_hub>=0.21.0->accelerate<2.0,>=1.10.0->oumi[gpu]) (1.2.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4->mlflow>=3.1->oumi[gpu]) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4->mlflow>=3.1->oumi[gpu]) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4->mlflow>=3.1->oumi[gpu]) (4.61.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4->mlflow>=3.1->oumi[gpu]) (1.4.9)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<4->mlflow>=3.1->oumi[gpu]) (3.2.5)\n", + "Requirement already satisfied: pydantic-extra-types>=2.10.5 in /usr/local/lib/python3.12/dist-packages (from pydantic-extra-types[pycountry]>=2.10.5->mistral_common>=1.8.2->mistral_common[audio,image]>=1.8.2->vllm<0.11,>=0.10->oumi[gpu]) (2.10.6)\n", + "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /usr/local/lib/python3.12/dist-packages (from jsonschema->skypilot<0.11,>=0.10.2->oumi[gpu]) (2025.9.1)\n", + "Requirement already satisfied: referencing>=0.28.4 in /usr/local/lib/python3.12/dist-packages (from jsonschema->skypilot<0.11,>=0.10.2->oumi[gpu]) (0.37.0)\n", + "Requirement already satisfied: rpds-py>=0.7.1 in /usr/local/lib/python3.12/dist-packages (from jsonschema->skypilot<0.11,>=0.10.2->oumi[gpu]) (0.30.0)\n", + "Requirement already satisfied: distro<2,>=1.7.0 in /usr/local/lib/python3.12/dist-packages (from openai>=1.99.1->vllm<0.11,>=0.10->oumi[gpu]) (1.9.0)\n", + "Requirement already satisfied: jiter<1,>=0.10.0 in /usr/local/lib/python3.12/dist-packages (from openai>=1.99.1->vllm<0.11,>=0.10->oumi[gpu]) (0.12.0)\n", + "Requirement already satisfied: sniffio in /usr/local/lib/python3.12/dist-packages (from openai>=1.99.1->vllm<0.11,>=0.10->oumi[gpu]) (1.3.1)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.12/dist-packages (from PrettyTable>=2.0.0->skypilot<0.11,>=0.10.2->oumi[gpu]) (0.2.14)\n", + "Requirement already satisfied: cupy-cuda12x in /usr/local/lib/python3.12/dist-packages (from ray[cgraph]>=2.48.0->vllm<0.11,>=0.10->oumi[gpu]) (13.6.0)\n", + "Requirement already satisfied: aiohttp_cors in /usr/local/lib/python3.12/dist-packages (from ray[default]>=2.41.0->verl<0.6,>=0.5->oumi[gpu]) (0.8.1)\n", + "Requirement already satisfied: colorful in /usr/local/lib/python3.12/dist-packages (from ray[default]>=2.41.0->verl<0.6,>=0.5->oumi[gpu]) (0.5.8)\n", + "Requirement already satisfied: py-spy>=0.4.0 in /usr/local/lib/python3.12/dist-packages (from ray[default]>=2.41.0->verl<0.6,>=0.5->oumi[gpu]) (0.4.1)\n", + "Requirement already satisfied: opencensus in /usr/local/lib/python3.12/dist-packages (from ray[default]>=2.41.0->verl<0.6,>=0.5->oumi[gpu]) (0.11.4)\n", + "Requirement already satisfied: opentelemetry-exporter-prometheus in /usr/local/lib/python3.12/dist-packages (from ray[default]>=2.41.0->verl<0.6,>=0.5->oumi[gpu]) (0.58b0)\n", + "Requirement already satisfied: smart_open in /usr/local/lib/python3.12/dist-packages (from ray[default]>=2.41.0->verl<0.6,>=0.5->oumi[gpu]) (7.5.0)\n", + "Requirement already satisfied: virtualenv!=20.21.1,>=20.0.24 in /usr/local/lib/python3.12/dist-packages (from ray[default]>=2.41.0->verl<0.6,>=0.5->oumi[gpu]) (20.35.4)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests>=2.32.2->datasets<3.3,>=3.2->oumi[gpu]) (3.4.4)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.12/dist-packages (from rich->skypilot<0.11,>=0.10.2->oumi[gpu]) (4.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.12/dist-packages (from rich->skypilot<0.11,>=0.10.2->oumi[gpu]) (2.19.2)\n", + "Requirement already satisfied: nltk in /usr/local/lib/python3.12/dist-packages (from rouge-score>=0.0.4->lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (3.9.1)\n", + "Requirement already satisfied: portalocker in /usr/local/lib/python3.12/dist-packages (from sacrebleu>=1.5.0->lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (3.2.0)\n", + "Requirement already satisfied: lxml in /usr/local/lib/python3.12/dist-packages (from sacrebleu>=1.5.0->lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (6.0.2)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=0.24.1->lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (1.5.2)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=0.24.1->lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (3.6.0)\n", + "Requirement already satisfied: greenlet>=1 in /usr/local/lib/python3.12/dist-packages (from sqlalchemy<3,>=1.4.0->mlflow>=3.1->oumi[gpu]) (3.3.0)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from sympy>=1.13.3->torch<2.9.0,>=2.6->oumi[gpu]) (1.3.0)\n", + "Requirement already satisfied: pyvers<0.2.0,>=0.1.0 in /usr/local/lib/python3.12/dist-packages (from tensordict!=0.9.0,<=0.9.1,>=0.8.0->verl<0.6,>=0.5->oumi[gpu]) (0.1.0)\n", + "Requirement already satisfied: httptools>=0.6.3 in /usr/local/lib/python3.12/dist-packages (from uvicorn[standard]<0.36.0,>=0.33.0->skypilot<0.11,>=0.10.2->oumi[gpu]) (0.7.1)\n", + "Requirement already satisfied: uvloop>=0.15.1 in /usr/local/lib/python3.12/dist-packages (from uvicorn[standard]<0.36.0,>=0.33.0->skypilot<0.11,>=0.10.2->oumi[gpu]) (0.22.1)\n", + "Requirement already satisfied: websockets>=10.4 in /usr/local/lib/python3.12/dist-packages (from uvicorn[standard]<0.36.0,>=0.33.0->skypilot<0.11,>=0.10.2->oumi[gpu]) (15.0.1)\n", + "Requirement already satisfied: simpleeval>=0.9.11 in /usr/local/lib/python3.12/dist-packages (from casbin->skypilot<0.11,>=0.10.2->oumi[gpu]) (1.0.3)\n", + "Requirement already satisfied: antlr4-python3-runtime==4.9.* in /usr/local/lib/python3.12/dist-packages (from hydra-core->verl<0.6,>=0.5->oumi[gpu]) (4.9.3)\n", + "Requirement already satisfied: DataProperty<2,>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from pytablewriter->lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (1.1.0)\n", + "Requirement already satisfied: mbstrdecoder<2,>=1.0.0 in /usr/local/lib/python3.12/dist-packages (from pytablewriter->lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (1.1.4)\n", + "Requirement already satisfied: pathvalidate<4,>=2.3.0 in /usr/local/lib/python3.12/dist-packages (from pytablewriter->lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (3.3.1)\n", + "Requirement already satisfied: tabledata<2,>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from pytablewriter->lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (1.3.4)\n", + "Requirement already satisfied: tcolorpy<1,>=0.0.5 in /usr/local/lib/python3.12/dist-packages (from pytablewriter->lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (0.1.7)\n", + "Requirement already satisfied: typepy<2,>=1.3.2 in /usr/local/lib/python3.12/dist-packages (from typepy[datetime]<2,>=1.3.2->pytablewriter->lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (1.3.4)\n", + "Requirement already satisfied: pycasbin>=2.0.0 in /usr/local/lib/python3.12/dist-packages (from sqlalchemy_adapter->skypilot<0.11,>=0.10.2->oumi[gpu]) (2.6.0)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.12/dist-packages (from cffi>=1.12->cryptography<47,>=43.0.0->mlflow>=3.1->oumi[gpu]) (2.23)\n", + "Requirement already satisfied: google-auth~=2.0 in /usr/local/lib/python3.12/dist-packages (from databricks-sdk<1,>=0.20.0->mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (2.43.0)\n", + "Requirement already satisfied: dnspython>=2.0.0 in /usr/local/lib/python3.12/dist-packages (from email-validator>=2.0.0->fastapi[standard]>=0.115.0->vllm<0.11,>=0.10->oumi[gpu]) (2.8.0)\n", + "Requirement already satisfied: rich-toolkit>=0.14.8 in /usr/local/lib/python3.12/dist-packages (from fastapi-cli>=0.0.8->fastapi-cli[standard]>=0.0.8; extra == \"standard\"->fastapi[standard]>=0.115.0->vllm<0.11,>=0.10->oumi[gpu]) (0.17.0)\n", + "Requirement already satisfied: fastapi-cloud-cli>=0.1.1 in /usr/local/lib/python3.12/dist-packages (from fastapi-cli[standard]>=0.0.8; extra == \"standard\"->fastapi[standard]>=0.115.0->vllm<0.11,>=0.10->oumi[gpu]) (0.6.0)\n", + "Requirement already satisfied: smmap<6,>=3.0.1 in /usr/local/lib/python3.12/dist-packages (from gitdb<5,>=4.0.1->gitpython<4,>=3.1.9->mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (5.0.2)\n", + "Requirement already satisfied: zipp>=3.20 in /usr/local/lib/python3.12/dist-packages (from importlib_metadata!=4.7.0,<9,>=3.7.0->mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (3.23.0)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.12/dist-packages (from markdown-it-py>=2.2.0->rich->skypilot<0.11,>=0.10.2->oumi[gpu]) (0.1.2)\n", + "Requirement already satisfied: chardet<6,>=3.0.4 in /usr/local/lib/python3.12/dist-packages (from mbstrdecoder<2,>=1.0.0->pytablewriter->lm_eval<0.5.0,>=0.4->lm_eval[wandb]<0.5.0,>=0.4->oumi[gpu]) (5.2.0)\n", + "Requirement already satisfied: opentelemetry-semantic-conventions==0.58b0 in /usr/local/lib/python3.12/dist-packages (from opentelemetry-sdk<3,>=1.9.0->mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (0.58b0)\n", + "Requirement already satisfied: wcmatch>=10.1 in /usr/local/lib/python3.12/dist-packages (from pycasbin>=2.0.0->sqlalchemy_adapter->skypilot<0.11,>=0.10.2->oumi[gpu]) (10.1)\n", + "Requirement already satisfied: pycountry>=23 in /usr/local/lib/python3.12/dist-packages (from pydantic-extra-types[pycountry]>=2.10.5->mistral_common>=1.8.2->mistral_common[audio,image]>=1.8.2->vllm<0.11,>=0.10->oumi[gpu]) (24.6.1)\n", + "Requirement already satisfied: distlib<1,>=0.3.7 in /usr/local/lib/python3.12/dist-packages (from virtualenv!=20.21.1,>=20.0.24->ray[default]>=2.41.0->verl<0.6,>=0.5->oumi[gpu]) (0.4.0)\n", + "Requirement already satisfied: fastrlock>=0.5 in /usr/local/lib/python3.12/dist-packages (from cupy-cuda12x->ray[cgraph]>=2.48.0->vllm<0.11,>=0.10->oumi[gpu]) (0.8.3)\n", + "Requirement already satisfied: soundfile>=0.12.1 in /usr/local/lib/python3.12/dist-packages (from mistral_common>=1.8.2->mistral_common[audio,image]>=1.8.2->vllm<0.11,>=0.10->oumi[gpu]) (0.13.1)\n", + "Requirement already satisfied: soxr>=0.5.0 in /usr/local/lib/python3.12/dist-packages (from mistral_common>=1.8.2->mistral_common[audio,image]>=1.8.2->vllm<0.11,>=0.10->oumi[gpu]) (1.0.0)\n", + "Requirement already satisfied: opencensus-context>=0.1.3 in /usr/local/lib/python3.12/dist-packages (from opencensus->ray[default]>=2.41.0->verl<0.6,>=0.5->oumi[gpu]) (0.1.3)\n", + "Requirement already satisfied: google-api-core<3.0.0,>=1.0.0 in /usr/local/lib/python3.12/dist-packages (from opencensus->ray[default]>=2.41.0->verl<0.6,>=0.5->oumi[gpu]) (2.28.1)\n", + "Requirement already satisfied: wrapt in /usr/local/lib/python3.12/dist-packages (from smart_open->ray[default]>=2.41.0->verl<0.6,>=0.5->oumi[gpu]) (2.0.1)\n", + "Requirement already satisfied: rignore>=0.5.1 in /usr/local/lib/python3.12/dist-packages (from fastapi-cloud-cli>=0.1.1->fastapi-cli[standard]>=0.0.8; extra == \"standard\"->fastapi[standard]>=0.115.0->vllm<0.11,>=0.10->oumi[gpu]) (0.7.6)\n", + "Requirement already satisfied: fastar>=0.8.0 in /usr/local/lib/python3.12/dist-packages (from fastapi-cloud-cli>=0.1.1->fastapi-cli[standard]>=0.0.8; extra == \"standard\"->fastapi[standard]>=0.115.0->vllm<0.11,>=0.10->oumi[gpu]) (0.8.0)\n", + "Requirement already satisfied: googleapis-common-protos<2.0.0,>=1.56.2 in /usr/local/lib/python3.12/dist-packages (from google-api-core<3.0.0,>=1.0.0->opencensus->ray[default]>=2.41.0->verl<0.6,>=0.5->oumi[gpu]) (1.72.0)\n", + "Requirement already satisfied: proto-plus<2.0.0,>=1.22.3 in /usr/local/lib/python3.12/dist-packages (from google-api-core<3.0.0,>=1.0.0->opencensus->ray[default]>=2.41.0->verl<0.6,>=0.5->oumi[gpu]) (1.26.1)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.12/dist-packages (from google-auth~=2.0->databricks-sdk<1,>=0.20.0->mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (0.4.2)\n", + "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.12/dist-packages (from google-auth~=2.0->databricks-sdk<1,>=0.20.0->mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (4.9.1)\n", + "Requirement already satisfied: bracex>=2.1.1 in /usr/local/lib/python3.12/dist-packages (from wcmatch>=10.1->pycasbin>=2.0.0->sqlalchemy_adapter->skypilot<0.11,>=0.10.2->oumi[gpu]) (2.6)\n", + "Requirement already satisfied: pyasn1<0.7.0,>=0.6.1 in /usr/local/lib/python3.12/dist-packages (from pyasn1-modules>=0.2.1->google-auth~=2.0->databricks-sdk<1,>=0.20.0->mlflow-skinny==3.7.0->mlflow>=3.1->oumi[gpu]) (0.6.1)\n", + "βœ… Dependencies installed\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Check GPU\n", + "import torch\n", + "print(f\"GPU Available: {torch.cuda.is_available()}\")\n", + "if torch.cuda.is_available():\n", + " print(f\"GPU: {torch.cuda.get_device_name(0)}\")\n", + " print(f\"VRAM: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB\")" + ], + "metadata": { + "id": "check_gpu", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "4bafc6c2-4f9b-4f56-8d9e-723466f4dec4" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "GPU Available: True\n", + "GPU: Tesla T4\n", + "VRAM: 15.8 GB\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Step 2: Upload Training Data" + ], + "metadata": { + "id": "step2" + } + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "print(\"Upload your generated_training_data.jsonl file:\")\n", + "uploaded = files.upload()\n", + "print(f\"\\nβœ… Uploaded: {list(uploaded.keys())}\")" + ], + "metadata": { + "id": "upload", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 127 + }, + "outputId": "9f9375e7-a371-4883-8283-7e47a64912cd" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Upload your generated_training_data.jsonl file:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving generated_training_data.jsonl to generated_training_data (6).jsonl\n", + "\n", + "βœ… Uploaded: ['generated_training_data (6).jsonl']\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Verify data\n", + "import json\n", + "with open('generated_training_data.jsonl') as f:\n", + " examples = [json.loads(line) for line in f]\n", + "print(f\"βœ… Loaded {len(examples)} training examples\")\n", + "print(f\"\\nSample:\")\n", + "print(json.dumps(examples[0], indent=2)[:500])" + ], + "metadata": { + "id": "verify_data", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "48c17e46-62c2-4ae7-af72-8a7073e53fb1" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "βœ… Loaded 500 training examples\n", + "\n", + "Sample:\n", + "{\n", + " \"messages\": [\n", + " {\n", + " \"role\": \"system\",\n", + " \"content\": \"You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\\n\\nYou MUST respond with ONLY valid JSON in this EXACT format:\\n{\\n \\\"architecture\\\": {\\n \\\"pattern\\\": \\\"serverless\\\" or \\\"microservices_ecs\\\" or \\\"kubernetes\\\" or \\\"event_driven\\\" or \\\"lift_and_shift\\\",\\n \\\"components\\\": [\\\"api_gateway\\\", \\\"lambda\\\", \\\"ecs_cluster\\\", \\\"alb\\\", \\\"rds\\\", \\\"elasticache\\\", etc.],\\n \\\"topology\\\": \\\"\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Step 3: Configure Training" + ], + "metadata": { + "id": "step3" + } + }, + { + "cell_type": "code", + "source": [ + "# Training configuration\n", + "MODEL_NAME = \"Qwen/Qwen2.5-1.5B-Instruct\" # Change to 3B if you have enough VRAM\n", + "OUTPUT_DIR = \"./trained_model\"\n", + "MAX_STEPS = 500\n", + "BATCH_SIZE = 1\n", + "GRADIENT_ACCUMULATION = 8\n", + "LEARNING_RATE = 1e-5\n", + "LORA_R = 64\n", + "LORA_ALPHA = 128\n", + "\n", + "print(f\"Model: {MODEL_NAME}\")\n", + "print(f\"Training steps: {MAX_STEPS}\")\n", + "print(f\"Effective batch size: {BATCH_SIZE * GRADIENT_ACCUMULATION}\")" + ], + "metadata": { + "id": "config", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ba8fe5b9-69e0-43e6-f22d-b9511c399e9b" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: Qwen/Qwen2.5-1.5B-Instruct\n", + "Training steps: 500\n", + "Effective batch size: 8\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Step 4: Train the Model" + ], + "metadata": { + "id": "step4" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "\n", + "from oumi import train\n", + "from oumi.core.configs import TrainingConfig\n", + "from oumi.core.configs.params.model_params import ModelParams\n", + "from oumi.core.configs.params.training_params import TrainingParams, TrainerType\n", + "from oumi.core.configs.params.data_params import DataParams, DatasetParams, DatasetSplitParams\n", + "from oumi.core.configs.params.peft_params import PeftParams\n", + "from pathlib import Path\n", + "\n", + "# Create training config\n", + "config = TrainingConfig(\n", + " model=ModelParams(\n", + " model_name=MODEL_NAME,\n", + " trust_remote_code=True,\n", + " ),\n", + " training=TrainingParams(\n", + " trainer_type=TrainerType.TRL_SFT,\n", + " output_dir=OUTPUT_DIR,\n", + " num_train_epochs=5,\n", + " per_device_train_batch_size=BATCH_SIZE,\n", + " gradient_accumulation_steps=GRADIENT_ACCUMULATION,\n", + " learning_rate=LEARNING_RATE,\n", + " max_steps=MAX_STEPS,\n", + " save_steps=100,\n", + " logging_steps=25,\n", + " use_peft=True,\n", + " warmup_ratio=0.1,\n", + " ),\n", + " data=DataParams(\n", + " train=DatasetSplitParams(\n", + " datasets=[\n", + " DatasetParams(\n", + " dataset_name=\"text_sft\",\n", + " dataset_path=str(Path(\"generated_training_data.jsonl\").absolute()),\n", + " )\n", + " ]\n", + " )\n", + " ),\n", + " peft=PeftParams(\n", + " lora_r=LORA_R,\n", + " lora_alpha=LORA_ALPHA,\n", + " lora_dropout=0.05,\n", + " ),\n", + ")\n", + "\n", + "print(\"πŸš€ Starting training...\")\n", + "print(\"=\"*60)\n", + "result = train(config)\n", + "print(\"=\"*60)\n", + "print(\"βœ… Training complete!\")" + ], + "metadata": { + "id": "train", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "e17b459ca44541b99fb2f5e027f35549", + "47214d8efd5b47f59d41cdcf73af784b", + "a0d5a41ba85544faa4203604bdd36def", + "d91de1410d814415993862fabb112ea1", + "8430e1101863452c9c351b526c55d156", + "ecafd17d15ef4272886372d57fe59772", + "d80b53f940fc4185b9e4f7110ad1e0ac", + "6f03a70dead044abb8d68d90924bc1de", + "05134369a9954c719b111adf38f70984", + "ebbeaa35db7d47b785a4b3c77bc4701d", + "81522af75b36485ca50cd4f823be7e1f", + "196ccdfca80642f9a9af22cdfaf96677", + "28471a590fb443baa08287d1d50d809d", + "43d5d912675b4486b760ad57747b4dac", + "688d010ec56e4adcba1b72c187b30521", + "26a39e57bbcb4408bd862bbf28135f06", + "5774c781aee6470b83b48df93b6dd5ac", + "1d37274a9a7e4774990f12751ee85e41", + "455fea62d27a411ea9715bf77de55552", + "1e176193720c4440a630c8c6d6d37574", + "87886767501e45f88567fe6c18853499", + "1e5a525cd6dd46dbb5799001fa4d0085", + "e60a6c98b61f4e38b185f3d932a20ba1", + "6c9693904ade42bc96244ce3f3bef34b", + "7a3f535f8dd149bfbb99cca9494db026", + "58846b24e702493198a0c46ed8f5ba75", + "72524b77db8944a7a4a781c00a68dae7", + "e6dd1d58a04248b78c49c0b3c94fef51", + "5fb28f3e16384ddca3b865526463e49c", + "0fc3a3d7ea784d318c7d064adbb543e5", + "950cca24f73941b4aeaa1b4be0302f72", + "4db8fbca9743489eb2862c2c804e2ae5", + "d0e67edc90f94b1e8f6a376bcfac3944", + "fe1b3c5d484144f782ab7e7afdf01763", + "3db89c0eb2ec41b2aaad1f529f32a5db", + "a18b6ac518ad4a698be8cd6eb7abb3fc", + "17acedd4523a4ad490fedc393194f280", + "54261000001047e299d508e9de1f7ae6", + "ea031d58c02e4a758de92865383dbab4", + "bc9c40622ff14d1399aaae01133d6d84", + "b46c070fa9984dfda31a33941b28cab7", + "d2836bc5b353440daa26071c325d0116", + "10945f347214454492014b7a6528b971", + "6e9c79d33279443d91749df184c18a18", + "bddd06c4708642dab45a279efb450338", + "c7c57d0a9dd34237a277e5dc3c995cc8", + "6c95a99bc1f84532a436a6fa9c02b918", + "990e6257b335436980e1408f93bcb08c", + "a12f70d9d554408b8ffa07900a426ff2", + "8ab755ca43c9403b885602848bf4d1df", + "af8cd544f4e24934b3158a0a3991424a", + "9c93c9ea94694f35bd5bba72f9637be6", + "3466e7fd8bee491d9c1e7bfb5ac931e6", + "0d086bbf196e4d52a33a80fb10432f29", + "b8a13a1271fb4e0f82feccce897b7157", + "44b86f4b039c439cae12bbaf52494ec6", + "15504882ded84c94917b8d78215482d0", + "f4bfbe619be849fabcda734c81cd3512", + "b7945bbc39864ca7873eef773f21412c", + "d46a2242ea1641ad8b54d36ad743c4b9", + "179fa7c1b4584059b36eb5cebc43810a", + "a3bcc05bc8ed406eb58dfb6f056c4da3", + "f0deded782694cd5813bc647a70fb257", + "dbe90c5b0a4b40af834b70c23cd8f271", + "17ee42c4bebd4bc78b215a22936ac018", + "ec525072f51a4daaa2514bac787f4b68", + "c01dbb5780144ca1802cb98d8de9efe6", + "981368edbdc84ef894a28497bc56113a", + "932de8084aba4a8c875ef6294a8d31b6", + "249a174fc87045b6814bcf66997a37d4", + "4369a364cc1b43a6b88714614b62ad86", + "6f290f716e3b43e3bc4b63fba3550f4a", + "2d8b22b663434ac78431d0f43bbc6808", + "9f85c02a5f2b4fbaa75fd3a654fd2780", + "dc50f8801d63492f89aeb6421360d89c", + "2531235bbbb64519a8e771cbca8f2a07", + "3fed80a4381d4db58a0b86cf44cefcfd", + "a87ff382495a4aa5bf50a099614cf8dd", + "83a8a627b9594614a981f1fda6e267dd", + "d3eb2891e0c5444d96a2b090f1b44309", + "4b1f43348d2b4a34b5c195b2af74f23b", + "bd576e5068754e829436b73cd89b52af", + "ec7125c9e59444508a395af3b0e481fb", + "76a14788c83e4dafab4df456d6a8894a", + "0f5cefe29ccd4bd48ed1ac3fe75cb127", + "9762ec5bc6e645b98a1be25fca099b25", + "6e256931061a4afb9cded340d38e98a2", + "58bf07467ad34ae987b91ee5d55af69d", + "02b5cc491a4b4822bcc847da5ed94dc9", + "f59063135e8d4bb3b36fa785b6187bfb", + "c83fd073214d47c0891f8c1df20235a2", + "d2f9e486c49249c4a64d8d7431247da0", + "a474faf62bf44f57a1f6c89d7823293d", + "018dd9ad501a46c1ab93144bb0f5fa7e", + "7d384cc04486487da8371651b07b3754", + "fefca726134041afaa0843520496fe1a", + "9f0b1e0f81504fb8b70eb493d44eb9bb", + "38f85c1b84094c2d87255d0a6d1af2dd", + "c557cf30f2da4192850ad676769c628b" + ] + }, + "outputId": "8019bab9-3329-4c81-fc1b-23f2b25b0bc5" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "error", + "ename": "AttributeError", + "evalue": "'MessageFactory' object has no attribute 'GetPrototype'", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: 'MessageFactory' object has no attribute 'GetPrototype'" + ] + }, + { + "output_type": "error", + "ename": "AttributeError", + "evalue": "'MessageFactory' object has no attribute 'GetPrototype'", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: 'MessageFactory' object has no attribute 'GetPrototype'" + ] + }, + { + "output_type": "error", + "ename": "AttributeError", + "evalue": "'MessageFactory' object has no attribute 'GetPrototype'", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: 'MessageFactory' object has no attribute 'GetPrototype'" + ] + }, + { + "output_type": "error", + "ename": "AttributeError", + "evalue": "'MessageFactory' object has no attribute 'GetPrototype'", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: 'MessageFactory' object has no attribute 'GetPrototype'" + ] + }, + { + "output_type": "error", + "ename": "AttributeError", + "evalue": "'MessageFactory' object has no attribute 'GetPrototype'", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: 'MessageFactory' object has no attribute 'GetPrototype'" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "πŸš€ Starting training...\n", + "============================================================\n", + "[2025-12-12 07:01:47,702][oumi][rank0][pid:9999][MainThread][INFO]][train.py:117] Creating training.output_dir: ./trained_model...\n", + "[2025-12-12 07:01:47,703][oumi][rank0][pid:9999][MainThread][INFO]][train.py:119] Created training.output_dir absolute path: /content/trained_model\n", + "[2025-12-12 07:01:47,705][oumi][rank0][pid:9999][MainThread][INFO]][train.py:117] Creating training.telemetry_dir: trained_model/telemetry...\n", + "[2025-12-12 07:01:47,706][oumi][rank0][pid:9999][MainThread][INFO]][train.py:119] Created training.telemetry_dir absolute path: /content/trained_model/telemetry\n", + "[2025-12-12 07:01:47,708][oumi][rank0][pid:9999][MainThread][INFO]][torch_utils.py:80] Torch version: 2.8.0+cu128. NumPy version: 1.26.4\n", + "[2025-12-12 07:01:47,709][oumi][rank0][pid:9999][MainThread][INFO]][torch_utils.py:88] CUDA version: 12.8 \n", + "[2025-12-12 07:01:47,736][oumi][rank0][pid:9999][MainThread][INFO]][torch_utils.py:91] CuDNN version: 91.0.2\n", + "[2025-12-12 07:01:47,874][oumi][rank0][pid:9999][MainThread][INFO]][torch_utils.py:124] CPU cores: 2 CUDA devices: 1\n", + "device(0)='Tesla T4' Capability: (7, 5) Memory: [Total: 14.74GiB Free: 14.64GiB Allocated: 0.0GiB Cached: 0.0GiB]\n", + "[2025-12-12 07:01:47,878][oumi][rank0][pid:9999][MainThread][INFO]][train.py:154] Oumi version: 0.5.0\n", + "[2025-12-12 07:01:47,897][oumi][rank0][pid:9999][MainThread][INFO]][train.py:318] Training config saved to trained_model/telemetry/training_config.yaml\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "config.json: 0%| | 0.00/660 [00:00 to instantiate model.\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "`torch_dtype` is deprecated! Use `dtype` instead!\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "model.safetensors: 0%| | 0.00/3.09G [00:00" + ], + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " [500/500 1:32:06, Epoch 7/8]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
252.291700
502.035300
751.732000
1001.436800
1251.106200
1500.764400
1750.518700
2000.378700
2250.302200
2500.270100
2750.240400
3000.213300
3250.201200
3500.184400
3750.178600
4000.168600
4250.159000
4500.156700
4750.157400
5000.148200

" + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[2025-12-12 08:34:55,028][oumi][rank0][pid:9999][MainThread][INFO]][train.py:566] Training is Complete.\n", + "[2025-12-12 08:34:55,037][oumi][rank0][pid:9999][MainThread][INFO]][device_utils.py:343] GPU Metrics After Training: GPU runtime info: NVidiaGpuRuntimeInfo(device_index=0, device_count=1, used_memory_mb=8057.0, temperature=76, fan_speed=None, fan_speeds=None, power_usage_watts=45.457, power_limit_watts=70.0, gpu_utilization=3, memory_utilization=0, performance_state=0, clock_speed_graphics=1590, clock_speed_sm=1590, clock_speed_memory=5000).\n", + "[2025-12-12 08:34:55,039][oumi][rank0][pid:9999][MainThread][INFO]][torch_utils.py:135] Peak GPU memory usage: 5.15 GB\n", + "[2025-12-12 08:34:55,041][oumi][rank0][pid:9999][MainThread][INFO]][train.py:573] Saving final state...\n", + "[2025-12-12 08:34:55,044][oumi][rank0][pid:9999][MainThread][INFO]][train.py:578] Saving final model...\n", + "[2025-12-12 08:34:55,524][oumi][rank0][pid:9999][MainThread][INFO]][hf_trainer.py:127] Model has been saved at ./trained_model\n", + "[2025-12-12 08:34:55,526][oumi][rank0][pid:9999][MainThread][INFO]][train.py:230] \n", + "\n", + "Β» We're always looking for feedback. What's one thing we can improve? https://oumi.ai/feedback\n", + "============================================================\n", + "βœ… Training complete!\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Step 5: Test the Model" + ], + "metadata": { + "id": "step5" + } + }, + { + "cell_type": "code", + "source": [ + "from oumi import infer\n", + "from oumi.core.configs import InferenceConfig\n", + "from oumi.core.configs.params.generation_params import GenerationParams\n", + "\n", + "# System prompt (same as training)\n", + "SYSTEM_PROMPT = '''You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n", + "\n", + "You MUST respond with ONLY valid JSON in this EXACT format:\n", + "{\n", + " \"architecture\": {\n", + " \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n", + " \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n", + " \"topology\": \"N services with PATTERN pattern on CLOUD\",\n", + " \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n", + " \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n", + " \"rationale\": \"Brief explanation of why this architecture\"\n", + " },\n", + " \"inputs\": {\n", + " \"service_count\": NUMBER,\n", + " \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n", + " },\n", + " \"source\": \"ai_recommendation\"\n", + "}\n", + "\n", + "Do NOT include any text outside the JSON. Components must be strings, not objects.'''\n", + "\n", + "# Configure inference\n", + "infer_config = InferenceConfig(\n", + " model=ModelParams(\n", + " model_name=MODEL_NAME,\n", + " adapter_model=OUTPUT_DIR,\n", + " trust_remote_code=True,\n", + " ),\n", + " generation=GenerationParams(\n", + " max_new_tokens=400,\n", + " temperature=0.1,\n", + " ),\n", + ")\n", + "\n", + "# Test inputs\n", + "test_inputs = [\n", + " \"Services: [api, auth, users], Language: python, DB: postgres, Cloud: aws, Latency p95: 200ms, Cost: $100/day\",\n", + " \"Services: [api], Language: javascript, DB: dynamodb, Cloud: aws, Latency p95: 50ms, Cost: $20/day\",\n", + "]\n", + "\n", + "print(\"Testing trained model:\")\n", + "print(\"=\"*60)\n", + "\n", + "for user_input in test_inputs:\n", + " prompt = f\"{SYSTEM_PROMPT}\\n\\nUser Input: {user_input}\\n\\nJSON Response:\"\n", + " response = infer(infer_config, [prompt])\n", + " result = str(response[0])\n", + "\n", + " # Clean up\n", + " if \"] metadata=\" in result:\n", + " result = result.split(\"] metadata=\")[0]\n", + " if \"ASSISTANT:\" in result:\n", + " result = result.split(\"ASSISTANT:\")[-1].strip()\n", + "\n", + " print(f\"\\nInput: {user_input[:50]}...\")\n", + " print(f\"Output: {result[:500]}\")\n", + " print(\"-\"*60)" + ], + "metadata": { + "id": "test", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "61ffd83e-a938-4911-d963-1ec3bb990a99" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Testing trained model:\n", + "============================================================\n", + "INFO 12-12 08:34:55 [__init__.py:216] Automatically detected platform cuda.\n", + "[2025-12-12 08:34:56,143][oumi][rank0][pid:9999][MainThread][WARNING]][infer.py:33] No inference engine specified. Using the default 'native' engine.\n", + "[2025-12-12 08:34:56,144][oumi][rank0][pid:9999][MainThread][INFO]][models.py:260] Building model using device_map: auto (DeviceRankInfo(world_size=1, rank=0, local_world_size=1, local_rank=0))...\n", + "[2025-12-12 08:34:56,145][oumi][rank0][pid:9999][MainThread][INFO]][models.py:336] Using model class: to instantiate model.\n", + "[2025-12-12 08:35:11,181][oumi][rank0][pid:9999][MainThread][INFO]][models.py:317] Loading PEFT adapter from: ./trained_model ...\n", + "[2025-12-12 08:35:12,054][oumi][rank0][pid:9999][MainThread][INFO]][models.py:544] Using the model's built-in chat template for model 'Qwen/Qwen2.5-1.5B-Instruct'.\n", + "[2025-12-12 08:35:12,066][oumi][rank0][pid:9999][MainThread][INFO]][native_text_inference_engine.py:151] Setting EOS token id to `151645`\n", + "\n", + "Input: Services: [api, auth, users], Language: python, DB...\n", + "Output: {\n", + " \"architecture\": {\n", + " \"pattern\": \"microservices_ecs\",\n", + " \"components\": [\"api_gateway\", \"ecs_cluster\", \"elasticache\", \"rds\", \"alb\"],\n", + " \"topology\": \"3 services with microservices_ecs pattern on aws\",\n", + " \"scaling_strategy\": \"horizontal_autoscaling\",\n", + " \"estimated_cost_tier\": \"medium\",\n", + " \"rationale\": \"3 services per cluster is optimal for ECS\"\n", + " },\n", + " \"inputs\": {\n", + " \"service_count\": 3,\n", + " \"cloud_provider\": \"aws\",\n", + " \"database\": \"postgres\",\n", + " \"language\": \"python\"\n", + " },\n", + " \"source\": \"ai_r\n", + "------------------------------------------------------------\n", + "[2025-12-12 08:36:24,489][oumi][rank0][pid:9999][MainThread][WARNING]][infer.py:33] No inference engine specified. Using the default 'native' engine.\n", + "[2025-12-12 08:36:24,491][oumi][rank0][pid:9999][MainThread][INFO]][models.py:260] Building model using device_map: auto (DeviceRankInfo(world_size=1, rank=0, local_world_size=1, local_rank=0))...\n", + "[2025-12-12 08:36:24,492][oumi][rank0][pid:9999][MainThread][INFO]][models.py:336] Using model class: to instantiate model.\n", + "[2025-12-12 08:36:25,929][oumi][rank0][pid:9999][MainThread][INFO]][models.py:317] Loading PEFT adapter from: ./trained_model ...\n", + "[2025-12-12 08:36:26,836][oumi][rank0][pid:9999][MainThread][INFO]][models.py:544] Using the model's built-in chat template for model 'Qwen/Qwen2.5-1.5B-Instruct'.\n", + "\n", + "Input: Services: [api], Language: javascript, DB: dynamod...\n", + "Output: {\n", + " \"architecture\": {\n", + " \"pattern\": \"microservices_ecs\",\n", + " \"components\": [\"api_gateway\", \"ecs_cluster\", \"elasticache\", \"rds\", \"cloudwatch\"],\n", + " \"topology\": \"1 services with microservices_ecs pattern on aws\",\n", + " \"scaling_strategy\": \"horizontal_autoscaling\",\n", + " \"estimated_cost_tier\": \"medium\",\n", + " \"rationale\": \"Microservices architecture with ECS is suitable for this setup\"\n", + " },\n", + " \"inputs\": {\n", + " \"service_count\": 1,\n", + " \"cloud_provider\": \"aws\",\n", + " \"database\": \"dynamodb\",\n", + " \"language\": \"ja\n", + "------------------------------------------------------------\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Step 6: Download Trained Model" + ], + "metadata": { + "id": "step6" + } + }, + { + "cell_type": "code", + "source": [ + "# Zip and download the trained model\n", + "!zip -r trained_model.zip ./trained_model\n", + "\n", + "from google.colab import files\n", + "files.download('trained_model.zip')\n", + "print(\"\\nβœ… Model downloaded! Extract and use locally.\")" + ], + "metadata": { + "id": "download", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "da066df7-1c58-4de8-b451-840862aa6a58" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " adding: trained_model/ (stored 0%)\n", + " adding: trained_model/training_args.bin (deflated 53%)\n", + " adding: trained_model/checkpoint-400/ (stored 0%)\n", + " adding: trained_model/checkpoint-400/training_args.bin (deflated 53%)\n", + " adding: trained_model/checkpoint-400/scheduler.pt (deflated 61%)\n", + " adding: trained_model/checkpoint-400/adapter_config.json (deflated 55%)\n", + " adding: trained_model/checkpoint-400/README.md (deflated 65%)\n", + " adding: trained_model/checkpoint-400/tokenizer.json (deflated 81%)\n", + " adding: trained_model/checkpoint-400/added_tokens.json (deflated 67%)\n", + " adding: trained_model/checkpoint-400/special_tokens_map.json (deflated 69%)\n", + " adding: trained_model/checkpoint-400/adapter_model.safetensors (deflated 8%)\n", + " adding: trained_model/checkpoint-400/merges.txt (deflated 57%)\n", + " adding: trained_model/checkpoint-400/chat_template.jinja (deflated 71%)\n", + " adding: trained_model/checkpoint-400/rng_state.pth (deflated 26%)\n", + " adding: trained_model/checkpoint-400/tokenizer_config.json (deflated 89%)\n", + " adding: trained_model/checkpoint-400/trainer_state.json (deflated 74%)\n", + " adding: trained_model/checkpoint-400/vocab.json (deflated 61%)\n", + " adding: trained_model/checkpoint-400/optimizer.pt (deflated 8%)\n", + " adding: trained_model/adapter_config.json (deflated 55%)\n", + " adding: trained_model/README.md (deflated 44%)\n", + " adding: trained_model/tokenizer.json (deflated 81%)\n", + " adding: trained_model/checkpoint-300/ (stored 0%)\n", + " adding: trained_model/checkpoint-300/training_args.bin (deflated 53%)\n", + " adding: trained_model/checkpoint-300/scheduler.pt (deflated 61%)\n", + " adding: trained_model/checkpoint-300/adapter_config.json (deflated 55%)\n", + " adding: trained_model/checkpoint-300/README.md (deflated 65%)\n", + " adding: trained_model/checkpoint-300/tokenizer.json (deflated 81%)\n", + " adding: trained_model/checkpoint-300/added_tokens.json (deflated 67%)\n", + " adding: trained_model/checkpoint-300/special_tokens_map.json (deflated 69%)\n", + " adding: trained_model/checkpoint-300/adapter_model.safetensors (deflated 8%)\n", + " adding: trained_model/checkpoint-300/merges.txt (deflated 57%)\n", + " adding: trained_model/checkpoint-300/chat_template.jinja (deflated 71%)\n", + " adding: trained_model/checkpoint-300/rng_state.pth (deflated 26%)\n", + " adding: trained_model/checkpoint-300/tokenizer_config.json (deflated 89%)\n", + " adding: trained_model/checkpoint-300/trainer_state.json (deflated 72%)\n", + " adding: trained_model/checkpoint-300/vocab.json (deflated 61%)\n", + " adding: trained_model/checkpoint-300/optimizer.pt (deflated 8%)\n", + " adding: trained_model/checkpoint-200/ (stored 0%)\n", + " adding: trained_model/checkpoint-200/training_args.bin (deflated 53%)\n", + " adding: trained_model/checkpoint-200/scheduler.pt (deflated 61%)\n", + " adding: trained_model/checkpoint-200/adapter_config.json (deflated 55%)\n", + " adding: trained_model/checkpoint-200/README.md (deflated 65%)\n", + " adding: trained_model/checkpoint-200/tokenizer.json (deflated 81%)\n", + " adding: trained_model/checkpoint-200/added_tokens.json (deflated 67%)\n", + " adding: trained_model/checkpoint-200/special_tokens_map.json (deflated 69%)\n", + " adding: trained_model/checkpoint-200/adapter_model.safetensors (deflated 8%)\n", + " adding: trained_model/checkpoint-200/merges.txt (deflated 57%)\n", + " adding: trained_model/checkpoint-200/chat_template.jinja (deflated 71%)\n", + " adding: trained_model/checkpoint-200/rng_state.pth (deflated 26%)\n", + " adding: trained_model/checkpoint-200/tokenizer_config.json (deflated 89%)\n", + " adding: trained_model/checkpoint-200/trainer_state.json (deflated 70%)\n", + " adding: trained_model/checkpoint-200/vocab.json (deflated 61%)\n", + " adding: trained_model/checkpoint-200/optimizer.pt (deflated 8%)\n", + " adding: trained_model/checkpoint-100/ (stored 0%)\n", + " adding: trained_model/checkpoint-100/training_args.bin (deflated 53%)\n", + " adding: trained_model/checkpoint-100/scheduler.pt (deflated 61%)\n", + " adding: trained_model/checkpoint-100/adapter_config.json (deflated 55%)\n", + " adding: trained_model/checkpoint-100/README.md (deflated 65%)\n", + " adding: trained_model/checkpoint-100/tokenizer.json (deflated 81%)\n", + " adding: trained_model/checkpoint-100/added_tokens.json (deflated 67%)\n", + " adding: trained_model/checkpoint-100/special_tokens_map.json (deflated 69%)\n", + " adding: trained_model/checkpoint-100/adapter_model.safetensors (deflated 8%)\n", + " adding: trained_model/checkpoint-100/merges.txt (deflated 57%)\n", + " adding: trained_model/checkpoint-100/chat_template.jinja (deflated 71%)\n", + " adding: trained_model/checkpoint-100/rng_state.pth (deflated 26%)\n", + " adding: trained_model/checkpoint-100/tokenizer_config.json (deflated 89%)\n", + " adding: trained_model/checkpoint-100/trainer_state.json (deflated 65%)\n", + " adding: trained_model/checkpoint-100/vocab.json (deflated 61%)\n", + " adding: trained_model/checkpoint-100/optimizer.pt (deflated 7%)\n", + " adding: trained_model/checkpoint-500/ (stored 0%)\n", + " adding: trained_model/checkpoint-500/training_args.bin (deflated 53%)\n", + " adding: trained_model/checkpoint-500/scheduler.pt (deflated 61%)\n", + " adding: trained_model/checkpoint-500/adapter_config.json (deflated 55%)\n", + " adding: trained_model/checkpoint-500/README.md (deflated 65%)\n", + " adding: trained_model/checkpoint-500/tokenizer.json (deflated 81%)\n", + " adding: trained_model/checkpoint-500/added_tokens.json (deflated 67%)\n", + " adding: trained_model/checkpoint-500/special_tokens_map.json (deflated 69%)\n", + " adding: trained_model/checkpoint-500/adapter_model.safetensors (deflated 8%)\n", + " adding: trained_model/checkpoint-500/merges.txt (deflated 57%)\n", + " adding: trained_model/checkpoint-500/chat_template.jinja (deflated 71%)\n", + " adding: trained_model/checkpoint-500/rng_state.pth (deflated 26%)\n", + " adding: trained_model/checkpoint-500/tokenizer_config.json (deflated 89%)\n", + " adding: trained_model/checkpoint-500/trainer_state.json (deflated 75%)\n", + " adding: trained_model/checkpoint-500/vocab.json (deflated 61%)\n", + " adding: trained_model/checkpoint-500/optimizer.pt (deflated 8%)\n", + " adding: trained_model/added_tokens.json (deflated 67%)\n", + " adding: trained_model/telemetry/ (stored 0%)\n", + " adding: trained_model/telemetry/devices_info.txt (deflated 17%)\n", + " adding: trained_model/telemetry/training_config.yaml (deflated 64%)\n", + " adding: trained_model/telemetry/world_size.json (deflated 26%)\n", + " adding: trained_model/special_tokens_map.json (deflated 69%)\n", + " adding: trained_model/adapter_model.safetensors (deflated 8%)\n", + " adding: trained_model/logs/ (stored 0%)\n", + " adding: trained_model/logs/rank_0000.log (deflated 73%)\n", + " adding: trained_model/merges.txt (deflated 57%)\n", + " adding: trained_model/chat_template.jinja (deflated 71%)\n", + " adding: trained_model/tokenizer_config.json (deflated 89%)\n", + " adding: trained_model/trainer_state.json (deflated 75%)\n", + " adding: trained_model/vocab.json (deflated 61%)\n", + " adding: trained_model/runs/ (stored 0%)\n", + " adding: trained_model/runs/Dec12_07-02-35_3d9120f71c1d/ (stored 0%)\n", + " adding: trained_model/runs/Dec12_07-02-35_3d9120f71c1d/events.out.tfevents.1765522957.3d9120f71c1d.9999.0 (deflated 66%)\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "\n", + " async function download(id, filename, size) {\n", + " if (!google.colab.kernel.accessAllowed) {\n", + " return;\n", + " }\n", + " const div = document.createElement('div');\n", + " const label = document.createElement('label');\n", + " label.textContent = `Downloading \"${filename}\": `;\n", + " div.appendChild(label);\n", + " const progress = document.createElement('progress');\n", + " progress.max = size;\n", + " div.appendChild(progress);\n", + " document.body.appendChild(div);\n", + "\n", + " const buffers = [];\n", + " let downloaded = 0;\n", + "\n", + " const channel = await google.colab.kernel.comms.open(id);\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + "\n", + " for await (const message of channel.messages) {\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + " if (message.buffers) {\n", + " for (const buffer of message.buffers) {\n", + " buffers.push(buffer);\n", + " downloaded += buffer.byteLength;\n", + " progress.value = downloaded;\n", + " }\n", + " }\n", + " }\n", + " const blob = new Blob(buffers, {type: 'application/binary'});\n", + " const a = document.createElement('a');\n", + " a.href = window.URL.createObjectURL(blob);\n", + " a.download = filename;\n", + " div.appendChild(a);\n", + " a.click();\n", + " div.remove();\n", + " }\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "download(\"download_c6f34579-2a3a-48d7-ba7d-5eb5e9134681\", \"trained_model.zip\", 537423617)" + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "βœ… Model downloaded! Extract and use locally.\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Next Steps\n", + "\n", + "1. **Download** the `trained_model.zip` file\n", + "2. **Extract** it to your local `oumi/trained_model/` directory\n", + "3. **Update** `run_inference.py` to use `Qwen/Qwen2.5-1.5B-Instruct`\n", + "4. **Run** inference locally with the improved model!" + ], + "metadata": { + "id": "next_steps" + } + } + ] +} \ No newline at end of file diff --git a/oumi/README.md b/oumi/README.md new file mode 100644 index 0000000..5d3906f --- /dev/null +++ b/oumi/README.md @@ -0,0 +1,95 @@ +# πŸ—οΈ InFoundry Oumi Architecture Brain + +Fine-tuned LLM for cloud architecture recommendations using the [Oumi](https://oumi.ai) framework. + +## πŸ€— Trained Model + +**Download from Hugging Face:** [crypticsayan/infoundry-architect](https://huggingface.co/crypticsayan/infoundry-architect/tree/main/) + +The model is a LoRA adapter trained on `Qwen/Qwen2.5-1.5B-Instruct` with 500 architecture examples. + +## Quick Start + +### 1. Install Dependencies +```bash +python -m venv venv +source venv/bin/activate # or venv/bin/activate.fish +pip install oumi[gpu] +``` + +### 2. Download Trained Model +```bash +# Option A: Clone from Hugging Face +git lfs install +git clone https://huggingface.co/crypticsayan/infoundry-architect trained_model + +# Option B: Or train your own (see below) +``` + +### 3. Run Inference +```bash +python run_inference.py +``` + +### 4. Start API Server +```bash +python serve.py +# API available at http://localhost:8000 +``` + +## Training Your Own Model + +### Generate Training Data +```bash +python generate_training_data.py --count 500 +``` + +### Train with Oumi +```bash +python train_sft.py +``` + +### Train on Cloud (Google Colab) +Upload `InFoundry_Cloud_Training.ipynb` to Colab with a T4 GPU. + +## Files + +| File | Description | +|------|-------------| +| `generate_training_data.py` | Rule-based training data generator | +| `generate_with_oumi.py` | Model-based data generator using Oumi inference | +| `train_sft.py` | SFT training script with LoRA | +| `run_inference.py` | Test the trained model | +| `serve.py` | FastAPI server for model inference | +| `InFoundry_Cloud_Training.ipynb` | Colab notebook for cloud training | +| `generated_training_data.jsonl` | 500 training examples | + +## Model Output Format + +The model outputs JSON matching this schema: + +```json +{ + "architecture": { + "pattern": "serverless|microservices_ecs|kubernetes|event_driven|lift_and_shift", + "components": ["api_gateway", "lambda", "rds", ...], + "topology": "N services with PATTERN on CLOUD", + "scaling_strategy": "horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa", + "estimated_cost_tier": "low|medium|high", + "rationale": "Explanation of architecture choice" + }, + "inputs": { + "service_count": 3, + "cloud_provider": "aws" + }, + "source": "ai_recommendation" +} +``` + +## Environment Variables + +| Variable | Default | Description | +|----------|---------|-------------| +| `USE_OUMI` | `true` | Use trained Oumi model | +| `USE_OLLAMA` | `false` | Fallback to Ollama | +| `OLLAMA_URL` | `http://localhost:11434` | Ollama server URL | diff --git a/oumi/generate_training_data.py b/oumi/generate_training_data.py new file mode 100644 index 0000000..341278a --- /dev/null +++ b/oumi/generate_training_data.py @@ -0,0 +1,498 @@ +""" +Oumi Training Data Generator for InFoundry Architect +Generates high-quality synthetic training data for cloud architecture decisions. + +Usage: + python generate_training_data.py [--count N] [--output FILE] + +Options: + --count N Number of training examples to generate (default: 50) + --output FILE Output file path (default: generated_training_data.jsonl) +""" + +import random +import argparse +import json +from pathlib import Path +from typing import List, Dict, Any + + +# Architecture decision rules and patterns +PATTERNS = { + "serverless": { + "triggers": ["single_service", "low_cost", "scheduled", "event_based", "prototype"], + "components": ["api_gateway", "lambda", "dynamodb", "s3", "eventbridge", "sqs", "sns"], + "scaling": "auto_managed", + }, + "microservices_ecs": { + "triggers": ["2-4_services", "containerized", "moderate_traffic"], + "components": ["ecs_cluster", "alb", "rds", "elasticache", "ecr", "cloudwatch"], + "scaling": "service_autoscaling", + }, + "kubernetes": { + "triggers": ["5+_services", "high_complexity", "ml_workloads", "gpu_required", "multi_tenant"], + "components": ["eks_cluster", "alb", "rds", "elasticache", "sqs", "s3", "karpenter"], + "scaling": "hpa_vpa_karpenter", + }, + "event_driven": { + "triggers": ["kafka", "real_time", "streaming", "iot", "event_processing"], + "components": ["msk", "kinesis", "lambda", "eventbridge", "dynamodb", "sqs"], + "scaling": "partition_based", + }, + "lift_and_shift": { + "triggers": ["monolith", "legacy", "quick_migration"], + "components": ["ec2", "alb", "rds", "efs", "elasticache"], + "scaling": "ec2_autoscaling", + }, +} + +# Service types for variety +SERVICE_TYPES = [ + ["api"], ["auth"], ["web"], ["backend"], ["frontend"], + ["api", "web"], ["auth", "users"], ["backend", "frontend"], + ["api", "worker"], ["auth", "payments"], + ["web", "api", "worker"], ["auth", "users", "payments"], + ["api", "consumer", "processor"], ["frontend", "backend", "gateway"], + ["web", "api", "auth", "worker"], ["backend", "frontend", "scheduler", "notifications"], + ["auth", "users", "products", "orders"], ["api", "worker", "scheduler", "reports"], + ["web", "api", "worker", "scheduler", "notifications"], + ["auth", "users", "products", "orders", "payments"], + ["auth", "users", "products", "orders", "payments", "shipping"], + ["gateway", "auth", "users", "catalog", "orders", "payments", "shipping", "notifications"], +] + +# Database options +DATABASES = ["postgres", "mysql", "mongodb", "dynamodb", "redis", "cassandra", "documentdb"] + +# Application types +APP_TYPES = [ + "startup", "e-commerce", "fintech", "saas", "enterprise", + "mobile_backend", "iot", "analytics", "gaming", "healthcare", + "media", "logistics", "crm", "erp", "social", +] + +# Languages +LANGUAGES = ["python", "javascript", "typescript", "go", "java", "rust"] + +# Queue systems +QUEUES = [None, "sqs", "rabbitmq", "kafka", "redis"] + + +def determine_pattern(services: List[str], db: str, app_type: str, + queue: str = None, gpu: bool = False, + scheduled: bool = False) -> str: + """ + Selects an architecture pattern string that fits the provided deployment requirements. + + Determines the most appropriate pattern from common architecture choices: + - Returns "kubernetes" for GPU workloads or large (5+) service counts. + - Returns "event_driven" when the queue is "kafka". + - Returns "serverless" for single-service cases (including scheduled single jobs or when using DynamoDB). + - Returns "microservices_ecs" for 2–4 services. + - Returns "lift_and_shift" for a single legacy or enterprise application. + + Parameters: + services (List[str]): List of service roles/components included in the application. + db (str): Primary database choice (e.g., "dynamodb", "postgres"). + app_type (str): Application domain/type (e.g., "enterprise", "legacy", "web"). + queue (str, optional): Queue system name if used (e.g., "kafka"); defaults to None. + gpu (bool, optional): True if the workload requires GPU resources; defaults to False. + scheduled (bool, optional): True if the workload is a scheduled/background job; defaults to False. + + Returns: + str: One of "kubernetes", "event_driven", "serverless", "microservices_ecs", or "lift_and_shift" indicating the chosen architecture pattern. + """ + num_services = len(services) + + # GPU workloads need Kubernetes + if gpu: + return "kubernetes" + + # Kafka indicates event-driven + if queue == "kafka": + return "event_driven" + + # Scheduled single job is serverless + if scheduled and num_services == 1: + return "serverless" + + # Single service with DynamoDB is serverless + if num_services == 1 and db == "dynamodb": + return "serverless" + + # 5+ services need Kubernetes + if num_services >= 5: + return "kubernetes" + + # 2-4 services fit ECS well + if 2 <= num_services <= 4: + return "microservices_ecs" + + # Single monolith service is lift-and-shift + if num_services == 1 and app_type in ["enterprise", "legacy"]: + return "lift_and_shift" + + # Default for single service + if num_services == 1: + return "serverless" + + return "microservices_ecs" + + +def generate_components(pattern: str, db: str, queue: str = None) -> List[str]: + """ + Produce component identifiers for a given architecture pattern, adjusted for the specified database and optional queue. + + Parameters: + pattern (str): Key name of the architecture pattern (must exist in PATTERNS). + db (str): Selected database type (used to include a matching database component). + queue (str, optional): Selected queue system; when provided, a corresponding queue component is included. + + Returns: + components (List[str]): List of unique component identifiers to include for the architecture. + """ + base_components = PATTERNS[pattern]["components"].copy() + + # Add database-specific components + db_mapping = { + "postgres": "rds", + "mysql": "rds", + "mongodb": "documentdb", + "dynamodb": "dynamodb", + "redis": "elasticache", + "cassandra": "keyspaces", + "documentdb": "documentdb", + } + + db_component = db_mapping.get(db, "rds") + if db_component not in base_components: + base_components.append(db_component) + + # Add queue if specified + queue_mapping = { + "sqs": "sqs", + "rabbitmq": "amazon_mq", + "kafka": "msk", + "redis": "elasticache", + } + + if queue and queue_mapping.get(queue) not in base_components: + base_components.append(queue_mapping.get(queue, "sqs")) + + # Remove duplicates and return + return list(set(base_components)) + + +def generate_rationale(pattern: str, services: List[str], db: str, + queue: str = None, gpu: bool = False) -> str: + """ + Selects a concise rationale explaining why a particular architecture pattern was chosen. + + Parameters: + pattern (str): Architecture pattern name (e.g., "serverless", "microservices_ecs", "kubernetes", "event_driven", "lift_and_shift"). + services (List[str]): List of service roles or components used to tailor the rationale (affects wording such as service count). + db (str): Database choice to include in the rationale when relevant. + queue (str, optional): Queue or streaming system to mention in event-driven rationales. + gpu (bool, optional): Whether GPU requirements should influence the rationale. + + Returns: + str: A single-sentence rationale chosen from candidate messages for the given pattern; returns a generic rationale if the pattern is not recognized. + """ + num_services = len(services) + + rationales = { + "serverless": [ + f"Single service with {db} is ideal for serverless architecture", + f"Low cost and scalability needs make Lambda the best choice", + f"Scheduled workloads are perfect for Lambda with EventBridge", + f"Simple API with {db} benefits from serverless auto-scaling", + ], + "microservices_ecs": [ + f"{num_services} services with {db} fit well in ECS containers", + f"Moderate complexity with {db} suits ECS orchestration", + f"Containerized {num_services}-service architecture optimal for ECS", + f"ECS provides good balance of control and managed infrastructure for {num_services} services", + ], + "kubernetes": [ + f"{num_services} services require Kubernetes for proper orchestration", + f"Complex architecture with {num_services} services needs EKS", + f"GPU workloads require EKS with specialized node groups", + f"Multi-service platform benefits from Kubernetes service mesh", + ], + "event_driven": [ + f"Kafka integration indicates event-driven architecture", + f"Real-time streaming with {queue} needs event-driven pattern", + f"Event-based processing with {db} suits MSK and Lambda", + f"Asynchronous workflows benefit from event-driven design", + ], + "lift_and_shift": [ + f"Monolith application suits EC2-based deployment", + f"Legacy {db} workload best migrated to EC2 with RDS", + f"Single service monolith optimal on EC2 instances", + ], + } + + return random.choice(rationales.get(pattern, ["Optimal architecture for requirements"])) + + +def generate_example() -> Dict[str, Any]: + """ + Generate a single synthetic training example in the chat-based format that conforms to the sample_architecture_plan.json schema. + + The returned example contains a "messages" list with three entries: + - system: an instruction enforcing an exact JSON schema for the response, + - user: a concise scenario describing services, language, database, cloud, optional queue/GPU/schedule, latency, and cost, + - assistant: a JSON string containing the recommended architecture, inputs metadata, and source. + + Returns: + example (Dict[str, Any]): A dictionary with a "messages" key whose value is a list of three message objects (system, user, assistant). The assistant message content is a JSON string with the keys "architecture", "inputs", and "source". + """ + # Random selections + services = random.choice(SERVICE_TYPES) + db = random.choice(DATABASES) + app_type = random.choice(APP_TYPES) + language = random.choice(LANGUAGES) + queue = random.choice(QUEUES) if random.random() > 0.6 else None + gpu = random.random() < 0.1 # 10% chance of GPU requirement + scheduled = random.random() < 0.15 and len(services) == 1 # 15% chance for single services + cloud_provider = random.choice(["aws", "gcp", "azure"]) + + # Generate latency and cost data + latency = random.choice([50, 100, 150, 200, 250, 300, 400, 500]) + cost = random.randint(10, 500) + + # Determine architecture + num_services = len(services) + pattern = determine_pattern(services, db, app_type, queue, gpu, scheduled) + components = generate_components(pattern, db, queue) + rationale = generate_rationale(pattern, services, db, queue, gpu) + scaling = PATTERNS[pattern]["scaling"] + + # Determine cost tier + if cost < 50: + cost_tier = "low" + elif cost < 200: + cost_tier = "medium" + else: + cost_tier = "high" + + # Scaling strategy mapping for output + scaling_strategies = { + "auto_managed": "serverless_autoscaling", + "service_autoscaling": "horizontal_autoscaling", + "hpa_vpa_karpenter": "kubernetes_hpa", + "partition_based": "event_driven_scaling", + "ec2_autoscaling": "vertical_autoscaling", + } + + # Build the prompt + prompt_parts = [f"Services: [{', '.join(services)}]"] + prompt_parts.append(f"Language: {language}") + prompt_parts.append(f"DB: {db}") + prompt_parts.append(f"Cloud: {cloud_provider}") + + if queue: + prompt_parts.append(f"Queues: {queue}") + if gpu: + prompt_parts.append("GPU: required") + if scheduled: + prompt_parts.append("Scheduled: true") + + prompt_parts.append(f"Latency p95: {latency}ms") + prompt_parts.append(f"Cost: ${cost}/day") + + user_content = ", ".join(prompt_parts) + + # Build the response matching sample_architecture_plan.json format + response = { + "architecture": { + "pattern": pattern, + "components": components, + "topology": f"{num_services} services with {pattern} pattern on {cloud_provider}", + "scaling_strategy": scaling_strategies.get(scaling, "horizontal_autoscaling"), + "estimated_cost_tier": cost_tier, + "rationale": rationale + }, + "inputs": { + "service_count": num_services, + "cloud_provider": cloud_provider, + "database": db, + "language": language + }, + "source": "ai_recommendation" + } + + # Create the training example in chat format with EXPLICIT schema + system_prompt = '''You are an expert cloud architect. Given service profiles, recommend the optimal architecture. + +You MUST respond with ONLY valid JSON in this EXACT format: +{ + "architecture": { + "pattern": "serverless" or "microservices_ecs" or "kubernetes" or "event_driven" or "lift_and_shift", + "components": ["api_gateway", "lambda", "ecs_cluster", "alb", "rds", "elasticache", etc.], + "topology": "N services with PATTERN pattern on CLOUD", + "scaling_strategy": "horizontal_autoscaling" or "serverless_autoscaling" or "kubernetes_hpa", + "estimated_cost_tier": "low" or "medium" or "high", + "rationale": "Brief explanation of why this architecture" + }, + "inputs": { + "service_count": NUMBER, + "cloud_provider": "aws" or "gcp" or "azure" + }, + "source": "ai_recommendation" +} + +Do NOT include any text outside the JSON. Components must be strings, not objects.''' + + example = { + "messages": [ + { + "role": "system", + "content": system_prompt + }, + { + "role": "user", + "content": user_content + }, + { + "role": "assistant", + "content": json.dumps(response) + } + ] + } + + return example + + +def generate_dpo_example() -> Dict[str, Any]: + """ + Create a DPO-style preference training example containing a prompt, a preferred solution, and a rejected alternative. + + The generated example simulates a human prompt describing services and constraints and two JSON-serialized responses: a chosen (correct) architecture and a rejected (suboptimal) alternative. + + Returns: + example (Dict[str, Any]): A dictionary with: + - "prompt" (str): A short human-facing prompt describing services, database, optional queue, and optional GPU requirement. + - "chosen" (str): A JSON string with keys "pattern", "components", and "rationale" representing the recommended architecture. + - "rejected" (str): A JSON string with keys "pattern", "components", and "rationale" representing a deliberately suboptimal alternative. + """ + # Generate a regular example first + services = random.choice(SERVICE_TYPES) + db = random.choice(DATABASES) + app_type = random.choice(APP_TYPES) + queue = random.choice(QUEUES) if random.random() > 0.6 else None + gpu = random.random() < 0.1 + + # Correct pattern + pattern = determine_pattern(services, db, app_type, queue, gpu, False) + components = generate_components(pattern, db, queue) + rationale = generate_rationale(pattern, services, db, queue, gpu) + + # Generate a suboptimal "rejected" response + wrong_patterns = [p for p in PATTERNS.keys() if p != pattern] + wrong_pattern = random.choice(wrong_patterns) + wrong_components = PATTERNS[wrong_pattern]["components"][:2] + wrong_rationales = [ + "Just use this", + "Should work fine", + "Simple solution", + "Default choice", + ] + + # Build prompt + prompt = f"You are a cloud architect. Services: [{', '.join(services)}], DB: {db}." + if queue: + prompt += f" Queues: {queue}." + if gpu: + prompt += " GPU: required." + prompt += " Recommend architecture." + + chosen = json.dumps({ + "pattern": pattern, + "components": components, + "rationale": rationale + }) + + rejected = json.dumps({ + "pattern": wrong_pattern, + "components": wrong_components, + "rationale": random.choice(wrong_rationales) + }) + + return { + "prompt": prompt, + "chosen": chosen, + "rejected": rejected + } + + +def main(): + """ + Generate synthetic SFT training examples and optional DPO preference examples, write them as newline-delimited JSON objects to disk, and print a summary and a sample example to stdout. + + Parses command-line arguments: + --count: number of examples to generate. + --output: file path for SFT JSONL output. + --dpo: when present, also generate DPO preference data. + --dpo-output: file path for DPO JSONL output. + + Side effects: + - Writes SFT examples to the specified output file in JSON Lines format. + - If --dpo is set, writes DPO examples to the specified DPO output file in JSON Lines format. + - Prints progress, saved file paths, and a sample training example to stdout. + """ + parser = argparse.ArgumentParser(description="Generate Oumi training data") + parser.add_argument("--count", type=int, default=50, + help="Number of training examples to generate") + parser.add_argument("--output", type=str, default="generated_training_data.jsonl", + help="Output file path") + parser.add_argument("--dpo", action="store_true", + help="Generate DPO preference data instead") + parser.add_argument("--dpo-output", type=str, default="generated_dpo_data.jsonl", + help="DPO output file path") + args = parser.parse_args() + + print("=" * 60) + print(" InFoundry Architect - Training Data Generator") + print("=" * 60) + + # Generate SFT data + sft_examples = [] + for i in range(args.count): + example = generate_example() + sft_examples.append(example) + + output_path = Path(args.output) + with open(output_path, "w") as f: + for example in sft_examples: + f.write(json.dumps(example) + "\n") + + print(f"\nβœ“ Generated {len(sft_examples)} SFT training examples") + print(f"βœ“ Saved to: {output_path}") + + # Generate DPO data if requested + if args.dpo: + dpo_examples = [] + for i in range(args.count): + example = generate_dpo_example() + dpo_examples.append(example) + + dpo_path = Path(args.dpo_output) + with open(dpo_path, "w") as f: + for example in dpo_examples: + f.write(json.dumps(example) + "\n") + + print(f"\nβœ“ Generated {len(dpo_examples)} DPO training examples") + print(f"βœ“ Saved to: {dpo_path}") + + print("\n" + "=" * 60) + print(" Sample training example:") + print("=" * 60) + sample = sft_examples[0] + print(f" User: {sample['messages'][1]['content']}") + print(f" Assistant: {sample['messages'][2]['content']}") + print("=" * 60) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/oumi/generate_with_oumi.py b/oumi/generate_with_oumi.py new file mode 100644 index 0000000..4ee5771 --- /dev/null +++ b/oumi/generate_with_oumi.py @@ -0,0 +1,230 @@ +""" +Oumi Synthetic Data Generator for InFoundry Architect +Uses Oumi's synthesize feature to generate training data with a teacher model. + +This leverages Oumi's data synthesis capabilities to create high-quality +training examples using a larger model as a teacher. +""" + +from oumi import infer +from oumi.core.configs import InferenceConfig +from oumi.core.configs.params.model_params import ModelParams +from oumi.core.configs.params.generation_params import GenerationParams +import json +import random +from pathlib import Path +from typing import List, Dict + + +# Seed scenarios to generate data for +SCENARIOS = [ + {"services": 1, "db": "dynamodb", "type": "serverless", "cloud": "aws"}, + {"services": 2, "db": "postgres", "type": "startup", "cloud": "aws"}, + {"services": 2, "db": "mongodb", "type": "mobile", "cloud": "gcp"}, + {"services": 3, "db": "redis", "type": "fintech", "cloud": "aws"}, + {"services": 3, "db": "postgres", "type": "saas", "cloud": "azure"}, + {"services": 4, "db": "mysql", "type": "e-commerce", "cloud": "aws"}, + {"services": 5, "db": "postgres", "type": "enterprise", "cloud": "aws"}, + {"services": 6, "db": "postgres", "type": "platform", "cloud": "gcp"}, + {"services": 1, "db": "dynamodb", "type": "cron", "cloud": "aws", "scheduled": True}, + {"services": 2, "db": "postgres", "type": "ml", "cloud": "aws", "gpu": True}, + {"services": 3, "db": "cassandra", "type": "iot", "cloud": "aws"}, + {"services": 2, "db": "postgres", "type": "streaming", "cloud": "aws", "queue": "kafka"}, +] + + +def create_prompt(scenario: Dict) -> str: + """ + Builds a text prompt instructing an expert cloud architect to produce a JSON-formatted architecture recommendation for the given scenario. + + Parameters: + scenario (Dict): Scenario specification with required keys: + - "services" (int): number of microservices + - "db" (str): database choice + - "type" (str): application type + - "cloud" (str): cloud provider + Optional keys: + - "scheduled" (bool): whether a scheduled/cron job is required + - "gpu" (bool): whether GPU resources are required + - "queue" (str): message queue type + + Returns: + str: A single string prompt that includes the scenario details and an explicit instruction to respond with a JSON object in the required schema. + """ + parts = [ + f"Services: {scenario['services']} microservices", + f"Database: {scenario['db']}", + f"Application type: {scenario['type']}", + f"Cloud provider: {scenario['cloud']}" + ] + + if scenario.get("scheduled"): + parts.append("Scheduled/cron job: yes") + if scenario.get("gpu"): + parts.append("GPU required: yes") + if scenario.get("queue"): + parts.append(f"Message queue: {scenario['queue']}") + + scenario_text = ", ".join(parts) + + return f"""You are an expert cloud architect. Given the following requirements, recommend an architecture. + +Requirements: {scenario_text} + +Respond with a JSON object in this exact format: +{{ + "architecture": {{ + "pattern": "serverless|microservices_ecs|kubernetes|event_driven|lift_and_shift", + "components": ["list", "of", "aws", "components"], + "topology": "description of topology", + "scaling_strategy": "horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa", + "estimated_cost_tier": "low|medium|high", + "rationale": "explanation of why this architecture" + }}, + "inputs": {{ + "service_count": number, + "cloud_provider": "aws|gcp|azure" + }}, + "source": "ai_recommendation" +}} + +Architecture recommendation (JSON only):""" + + +def generate_with_oumi(model_name: str = "Qwen/Qwen2.5-1.5B-Instruct", + use_trained: bool = False, + num_examples: int = 50) -> List[Dict]: + """ + Generate a set of synthetic chat-style training examples by prompting Oumi and collecting its JSON-formatted architecture recommendations. + + This function configures an Oumi inference model (optionally with a trained adapter), repeatedly selects and slightly randomizes seed scenarios, builds prompts, calls Oumi to generate an assistant response, and wraps each result into a chat-style example containing system/user/assistant messages plus the scenario under `metadata`. Failures for individual examples are caught and do not stop the overall run. + + Parameters: + model_name (str): Base model identifier used for inference. + use_trained (bool): If True, attach a local trained adapter at "./trained_model" to the base model. + num_examples (int): Number of synthetic examples to generate. + + Returns: + List[Dict]: A list of examples where each example is a dict with keys: + - "messages": List of message dicts with roles ("system", "user", "assistant") and corresponding content. + - "metadata": The scenario dictionary used to generate the prompt for that example. + """ + + # Configure the model + config = InferenceConfig( + model=ModelParams( + model_name=model_name, + adapter_model="./trained_model" if use_trained else None, + trust_remote_code=True, + ), + generation=GenerationParams( + max_new_tokens=512, + temperature=0.7, # Some creativity for variety + top_p=0.9, + ), + ) + + print("=" * 60) + print(" Oumi Synthetic Data Generator") + print("=" * 60) + print(f" Model: {model_name}") + print(f" Using trained adapter: {use_trained}") + print(f" Generating: {num_examples} examples") + print("=" * 60) + + training_examples = [] + + for i in range(num_examples): + # Pick a random scenario or create variations + scenario = random.choice(SCENARIOS).copy() + + # Add some randomness + scenario["services"] = random.randint(1, 8) + scenario["db"] = random.choice(["postgres", "mysql", "mongodb", "dynamodb", "redis"]) + scenario["cloud"] = random.choice(["aws", "gcp", "azure"]) + + prompt = create_prompt(scenario) + + print(f"\n[{i+1}/{num_examples}] Generating for {scenario['type']} with {scenario['services']} services...") + + try: + # Use Oumi to generate + response = infer(config, [prompt]) + + # Extract the response + resp_text = str(response[0]) + + # Try to extract JSON from response + if "ASSISTANT:" in resp_text: + resp_text = resp_text.split("ASSISTANT:")[-1].strip() + + # Remove metadata artifacts + if "] metadata=" in resp_text: + resp_text = resp_text.split("] metadata=")[0] + + # Create training example in chat format + user_content = f"Services: [{', '.join(['svc' + str(j) for j in range(scenario['services'])])}], Language: python, DB: {scenario['db']}, Cloud: {scenario['cloud']}" + + example = { + "messages": [ + { + "role": "system", + "content": "You are an expert cloud architect. Given service profiles and requirements, recommend the optimal architecture. Respond with valid JSON." + }, + { + "role": "user", + "content": user_content + }, + { + "role": "assistant", + "content": resp_text + } + ], + "metadata": scenario + } + + training_examples.append(example) + print(f" βœ“ Generated") + + except Exception as e: + print(f" βœ— Error: {e}") + + return training_examples + + +def main(): + """ + Run the CLI to generate synthetic training examples with Oumi and save them as a JSONL file. + + Parses command-line arguments (--count, --output, --use-trained, --model), invokes generate_with_oumi with those options to produce the requested number of examples, and writes each example as a separate JSON object line to the specified output file. + """ + import argparse + + parser = argparse.ArgumentParser(description="Generate synthetic training data with Oumi") + parser.add_argument("--count", type=int, default=20, help="Number of examples") + parser.add_argument("--output", type=str, default="oumi_synthetic_data.jsonl", help="Output file") + parser.add_argument("--use-trained", action="store_true", help="Use the trained model adapter") + parser.add_argument("--model", type=str, default="Qwen/Qwen2.5-1.5B-Instruct", help="Base model") + args = parser.parse_args() + + # Generate data + examples = generate_with_oumi( + model_name=args.model, + use_trained=args.use_trained, + num_examples=args.count + ) + + # Save to file + output_path = Path(args.output) + with open(output_path, "w") as f: + for example in examples: + f.write(json.dumps(example) + "\n") + + print("\n" + "=" * 60) + print(f"βœ“ Generated {len(examples)} examples using Oumi") + print(f"βœ“ Saved to: {output_path}") + print("=" * 60) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/oumi/generated_training_data.jsonl b/oumi/generated_training_data.jsonl new file mode 100644 index 0000000..cc4f61f --- /dev/null +++ b/oumi/generated_training_data.jsonl @@ -0,0 +1,500 @@ +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: python, DB: documentdb, Cloud: aws, Latency p95: 400ms, Cost: $494/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with documentdb benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: go, DB: dynamodb, Cloud: aws, Latency p95: 200ms, Cost: $122/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with dynamodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: java, DB: mongodb, Cloud: aws, GPU: required, Latency p95: 200ms, Cost: $222/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: rust, DB: cassandra, Cloud: gcp, Latency p95: 150ms, Cost: $314/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: javascript, DB: dynamodb, Cloud: aws, Latency p95: 200ms, Cost: $300/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: java, DB: cassandra, Cloud: azure, Queues: redis, GPU: required, Latency p95: 100ms, Cost: $269/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"2 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: go, DB: mongodb, Cloud: gcp, Latency p95: 50ms, Cost: $189/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: typescript, DB: cassandra, Cloud: aws, Latency p95: 500ms, Cost: $99/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: go, DB: documentdb, Cloud: aws, Latency p95: 300ms, Cost: $106/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: javascript, DB: redis, Cloud: gcp, Queues: redis, Latency p95: 400ms, Cost: $195/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: rust, DB: documentdb, Cloud: gcp, Queues: redis, Latency p95: 100ms, Cost: $100/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"elasticache\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: java, DB: dynamodb, Cloud: azure, Latency p95: 150ms, Cost: $495/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 3 services\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: typescript, DB: mysql, Cloud: azure, Latency p95: 100ms, Cost: $368/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with mysql fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend], Language: python, DB: redis, Cloud: gcp, GPU: required, Latency p95: 250ms, Cost: $155/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"1 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Complex architecture with 1 services needs EKS\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: python, DB: redis, Cloud: azure, Latency p95: 300ms, Cost: $177/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with redis suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: typescript, DB: mysql, Cloud: gcp, Queues: kafka, Latency p95: 400ms, Cost: $106/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\", \"kinesis\"], \"topology\": \"5 services with event_driven pattern on gcp\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Kafka integration indicates event-driven architecture\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: go, DB: postgres, Cloud: aws, Latency p95: 400ms, Cost: $266/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 3 services\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: typescript, DB: cassandra, Cloud: gcp, Latency p95: 100ms, Cost: $194/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with cassandra suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: typescript, DB: mongodb, Cloud: gcp, Queues: rabbitmq, Latency p95: 50ms, Cost: $151/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"amazon_mq\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Simple API with mongodb benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: python, DB: documentdb, Cloud: azure, Queues: redis, Latency p95: 250ms, Cost: $25/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: python, DB: cassandra, Cloud: azure, Latency p95: 200ms, Cost: $11/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 3 services\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: javascript, DB: mongodb, Cloud: azure, Latency p95: 400ms, Cost: $479/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with mongodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: typescript, DB: postgres, Cloud: aws, Latency p95: 150ms, Cost: $254/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with postgres benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: python, DB: redis, Cloud: gcp, Latency p95: 500ms, Cost: $426/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 6 services needs EKS\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: java, DB: redis, Cloud: azure, Latency p95: 250ms, Cost: $168/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"3 services with redis fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: javascript, DB: dynamodb, Cloud: azure, Latency p95: 100ms, Cost: $308/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with dynamodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: go, DB: mysql, Cloud: aws, Latency p95: 300ms, Cost: $88/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with mysql suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: javascript, DB: mongodb, Cloud: aws, Latency p95: 100ms, Cost: $310/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: python, DB: redis, Cloud: azure, GPU: required, Latency p95: 400ms, Cost: $21/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"4 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: rust, DB: mysql, Cloud: aws, Latency p95: 150ms, Cost: $114/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"5 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: javascript, DB: mongodb, Cloud: aws, Latency p95: 50ms, Cost: $469/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"4 services with mongodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: python, DB: dynamodb, Cloud: azure, Latency p95: 100ms, Cost: $463/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: python, DB: dynamodb, Cloud: gcp, GPU: required, Latency p95: 50ms, Cost: $167/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"2 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: rust, DB: redis, Cloud: azure, Queues: redis, Latency p95: 500ms, Cost: $110/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: javascript, DB: redis, Cloud: azure, Latency p95: 250ms, Cost: $194/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"5 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: go, DB: documentdb, Cloud: azure, Latency p95: 400ms, Cost: $257/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: python, DB: mysql, Cloud: gcp, Queues: sqs, Latency p95: 300ms, Cost: $133/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: javascript, DB: redis, Cloud: gcp, Queues: rabbitmq, Latency p95: 250ms, Cost: $290/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"amazon_mq\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: javascript, DB: redis, Cloud: gcp, Latency p95: 400ms, Cost: $439/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with redis fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: rust, DB: redis, Cloud: aws, Scheduled: true, Latency p95: 250ms, Cost: $219/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"redis\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: java, DB: postgres, Cloud: gcp, Latency p95: 100ms, Cost: $240/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: java, DB: dynamodb, Cloud: gcp, Scheduled: true, Latency p95: 400ms, Cost: $213/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Single service with dynamodb is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: java, DB: documentdb, Cloud: gcp, Latency p95: 500ms, Cost: $208/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with documentdb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: javascript, DB: dynamodb, Cloud: azure, GPU: required, Latency p95: 200ms, Cost: $227/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"2 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 2 services needs EKS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: typescript, DB: redis, Cloud: azure, GPU: required, Latency p95: 50ms, Cost: $316/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"6 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: javascript, DB: mysql, Cloud: azure, Latency p95: 400ms, Cost: $167/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Simple API with mysql benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: javascript, DB: documentdb, Cloud: azure, Queues: redis, Latency p95: 100ms, Cost: $71/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: javascript, DB: mysql, Cloud: gcp, GPU: required, Latency p95: 200ms, Cost: $167/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"1 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: java, DB: dynamodb, Cloud: azure, Queues: rabbitmq, Latency p95: 200ms, Cost: $227/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"3 services with dynamodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: python, DB: mysql, Cloud: azure, Latency p95: 400ms, Cost: $296/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with mysql benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: typescript, DB: mongodb, Cloud: azure, Latency p95: 250ms, Cost: $180/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"4 services with mongodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: typescript, DB: mysql, Cloud: aws, Queues: rabbitmq, Latency p95: 150ms, Cost: $204/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"amazon_mq\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 6 services needs EKS\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend], Language: rust, DB: dynamodb, Cloud: azure, Latency p95: 300ms, Cost: $492/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: java, DB: cassandra, Cloud: gcp, Queues: sqs, Latency p95: 400ms, Cost: $36/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Complex architecture with 5 services needs EKS\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: typescript, DB: cassandra, Cloud: azure, Latency p95: 150ms, Cost: $276/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: typescript, DB: documentdb, Cloud: aws, Latency p95: 200ms, Cost: $112/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Simple API with documentdb benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: rust, DB: mysql, Cloud: azure, Queues: sqs, Scheduled: true, Latency p95: 200ms, Cost: $266/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with mysql benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: javascript, DB: postgres, Cloud: gcp, Latency p95: 400ms, Cost: $339/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: typescript, DB: postgres, Cloud: azure, Latency p95: 300ms, Cost: $440/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Single service with postgres is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: rust, DB: redis, Cloud: azure, Queues: kafka, Latency p95: 150ms, Cost: $25/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"3 services with event_driven pattern on azure\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Kafka integration indicates event-driven architecture\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: typescript, DB: dynamodb, Cloud: aws, Latency p95: 150ms, Cost: $351/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: java, DB: redis, Cloud: aws, Latency p95: 250ms, Cost: $108/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"5 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"redis\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: go, DB: postgres, Cloud: azure, Latency p95: 500ms, Cost: $252/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: javascript, DB: dynamodb, Cloud: azure, Latency p95: 150ms, Cost: $153/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: javascript, DB: postgres, Cloud: gcp, Scheduled: true, Latency p95: 150ms, Cost: $438/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: java, DB: mongodb, Cloud: gcp, Latency p95: 500ms, Cost: $351/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: java, DB: mongodb, Cloud: aws, GPU: required, Latency p95: 250ms, Cost: $205/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"4 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: rust, DB: dynamodb, Cloud: gcp, Queues: kafka, Latency p95: 200ms, Cost: $133/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"1 services with event_driven pattern on gcp\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Kafka integration indicates event-driven architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: typescript, DB: redis, Cloud: gcp, Latency p95: 400ms, Cost: $427/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 3 services\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: go, DB: redis, Cloud: azure, Queues: kafka, Latency p95: 300ms, Cost: $174/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"5 services with event_driven pattern on azure\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Kafka integration indicates event-driven architecture\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: java, DB: postgres, Cloud: azure, Queues: redis, Latency p95: 300ms, Cost: $303/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with postgres fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: rust, DB: mongodb, Cloud: aws, Latency p95: 500ms, Cost: $258/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Single service with mongodb is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: javascript, DB: dynamodb, Cloud: gcp, Queues: rabbitmq, Latency p95: 500ms, Cost: $111/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"3 services with dynamodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: typescript, DB: redis, Cloud: gcp, Latency p95: 50ms, Cost: $115/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: go, DB: mongodb, Cloud: azure, Queues: rabbitmq, GPU: required, Latency p95: 100ms, Cost: $176/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"amazon_mq\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"2 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"2 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: rust, DB: dynamodb, Cloud: gcp, Queues: sqs, Latency p95: 300ms, Cost: $200/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with dynamodb benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: rust, DB: mysql, Cloud: azure, Latency p95: 400ms, Cost: $405/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with mysql benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: java, DB: postgres, Cloud: aws, Latency p95: 400ms, Cost: $182/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: typescript, DB: mysql, Cloud: azure, GPU: required, Latency p95: 500ms, Cost: $290/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"2 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: rust, DB: postgres, Cloud: azure, Latency p95: 300ms, Cost: $437/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: rust, DB: mysql, Cloud: azure, Latency p95: 500ms, Cost: $416/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with mysql fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: rust, DB: documentdb, Cloud: aws, Scheduled: true, Latency p95: 100ms, Cost: $500/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: python, DB: mysql, Cloud: gcp, Queues: kafka, Latency p95: 500ms, Cost: $443/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\", \"kinesis\"], \"topology\": \"1 services with event_driven pattern on gcp\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Asynchronous workflows benefit from event-driven design\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: rust, DB: cassandra, Cloud: azure, Latency p95: 500ms, Cost: $466/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"keyspaces\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with cassandra benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: typescript, DB: documentdb, Cloud: gcp, Latency p95: 100ms, Cost: $178/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with documentdb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: javascript, DB: cassandra, Cloud: aws, GPU: required, Latency p95: 100ms, Cost: $492/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"4 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"4 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: javascript, DB: cassandra, Cloud: aws, Queues: sqs, Latency p95: 200ms, Cost: $310/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with cassandra suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: go, DB: mysql, Cloud: azure, Latency p95: 500ms, Cost: $227/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with mysql fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: python, DB: mysql, Cloud: gcp, Latency p95: 200ms, Cost: $343/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Single service with mysql is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: go, DB: dynamodb, Cloud: aws, Latency p95: 200ms, Cost: $481/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: rust, DB: documentdb, Cloud: aws, Latency p95: 250ms, Cost: $435/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"5 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: javascript, DB: postgres, Cloud: aws, Latency p95: 250ms, Cost: $370/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: javascript, DB: dynamodb, Cloud: aws, Latency p95: 100ms, Cost: $192/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: javascript, DB: postgres, Cloud: azure, Queues: sqs, GPU: required, Latency p95: 300ms, Cost: $248/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"2 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: typescript, DB: mysql, Cloud: azure, Latency p95: 300ms, Cost: $460/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with mysql benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: typescript, DB: documentdb, Cloud: azure, Queues: kafka, Latency p95: 400ms, Cost: $307/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"6 services with event_driven pattern on azure\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Asynchronous workflows benefit from event-driven design\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: java, DB: dynamodb, Cloud: azure, Latency p95: 300ms, Cost: $104/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"3 services with dynamodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: javascript, DB: mongodb, Cloud: aws, Queues: kafka, Latency p95: 250ms, Cost: $415/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"2 services with event_driven pattern on aws\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Real-time streaming with kafka needs event-driven pattern\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: python, DB: documentdb, Cloud: aws, GPU: required, Latency p95: 200ms, Cost: $266/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"3 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 3 services needs EKS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: java, DB: documentdb, Cloud: gcp, Latency p95: 300ms, Cost: $59/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 3 services\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: javascript, DB: cassandra, Cloud: gcp, Latency p95: 150ms, Cost: $90/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: java, DB: documentdb, Cloud: azure, Queues: redis, Latency p95: 300ms, Cost: $214/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 3 services\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: typescript, DB: dynamodb, Cloud: gcp, Latency p95: 500ms, Cost: $475/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with dynamodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: go, DB: redis, Cloud: aws, GPU: required, Latency p95: 100ms, Cost: $274/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"4 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"redis\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: javascript, DB: dynamodb, Cloud: azure, Latency p95: 400ms, Cost: $383/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 5 services needs EKS\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: python, DB: dynamodb, Cloud: aws, Latency p95: 200ms, Cost: $489/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 6 services needs EKS\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: javascript, DB: mongodb, Cloud: azure, Latency p95: 50ms, Cost: $438/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"6 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: java, DB: documentdb, Cloud: gcp, Queues: redis, Latency p95: 300ms, Cost: $42/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: javascript, DB: cassandra, Cloud: gcp, Queues: sqs, GPU: required, Latency p95: 150ms, Cost: $391/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"3 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 3 services needs EKS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: typescript, DB: cassandra, Cloud: aws, Latency p95: 300ms, Cost: $210/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: rust, DB: dynamodb, Cloud: gcp, Queues: sqs, Latency p95: 50ms, Cost: $146/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"2 services with dynamodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: rust, DB: redis, Cloud: gcp, Latency p95: 200ms, Cost: $407/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with redis suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: go, DB: mysql, Cloud: gcp, Latency p95: 250ms, Cost: $469/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: typescript, DB: documentdb, Cloud: gcp, Latency p95: 300ms, Cost: $195/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: rust, DB: dynamodb, Cloud: aws, Latency p95: 200ms, Cost: $324/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: rust, DB: documentdb, Cloud: azure, Queues: kafka, Latency p95: 400ms, Cost: $454/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"1 services with event_driven pattern on azure\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Event-based processing with documentdb suits MSK and Lambda\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: java, DB: mysql, Cloud: aws, Latency p95: 150ms, Cost: $290/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"4 services with mysql fit well in ECS containers\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: javascript, DB: documentdb, Cloud: gcp, Queues: kafka, Latency p95: 50ms, Cost: $362/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"1 services with event_driven pattern on gcp\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Asynchronous workflows benefit from event-driven design\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: rust, DB: dynamodb, Cloud: gcp, Queues: sqs, Latency p95: 400ms, Cost: $29/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"5 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: rust, DB: cassandra, Cloud: aws, Queues: redis, Latency p95: 50ms, Cost: $326/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"lift_and_shift\", \"components\": [\"alb\", \"ec2\", \"efs\", \"elasticache\", \"keyspaces\", \"rds\"], \"topology\": \"1 services with lift_and_shift pattern on aws\", \"scaling_strategy\": \"vertical_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Legacy cassandra workload best migrated to EC2 with RDS\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: go, DB: documentdb, Cloud: aws, Queues: sqs, Latency p95: 200ms, Cost: $500/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with documentdb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: javascript, DB: dynamodb, Cloud: azure, Latency p95: 400ms, Cost: $265/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with dynamodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: typescript, DB: mysql, Cloud: gcp, GPU: required, Latency p95: 500ms, Cost: $78/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"4 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: javascript, DB: dynamodb, Cloud: gcp, Latency p95: 300ms, Cost: $134/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"2 services with dynamodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: typescript, DB: mongodb, Cloud: aws, Latency p95: 150ms, Cost: $295/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: rust, DB: cassandra, Cloud: gcp, Latency p95: 100ms, Cost: $257/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with cassandra suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: rust, DB: postgres, Cloud: gcp, Latency p95: 500ms, Cost: $210/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: rust, DB: mysql, Cloud: azure, Latency p95: 400ms, Cost: $417/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: rust, DB: dynamodb, Cloud: gcp, Latency p95: 150ms, Cost: $484/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: javascript, DB: mysql, Cloud: gcp, Queues: rabbitmq, Latency p95: 500ms, Cost: $41/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"amazon_mq\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Complex architecture with 5 services needs EKS\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: typescript, DB: mongodb, Cloud: gcp, Latency p95: 150ms, Cost: $488/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: typescript, DB: cassandra, Cloud: aws, Latency p95: 500ms, Cost: $446/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with cassandra fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: go, DB: redis, Cloud: aws, Queues: sqs, Latency p95: 100ms, Cost: $101/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"5 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"redis\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: python, DB: mysql, Cloud: gcp, Latency p95: 150ms, Cost: $463/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with mysql suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: typescript, DB: mongodb, Cloud: aws, Queues: redis, GPU: required, Latency p95: 50ms, Cost: $148/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"2 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: typescript, DB: redis, Cloud: gcp, Queues: sqs, Latency p95: 50ms, Cost: $149/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"3 services with redis fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: javascript, DB: postgres, Cloud: aws, Latency p95: 300ms, Cost: $385/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: java, DB: postgres, Cloud: gcp, Latency p95: 150ms, Cost: $281/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with postgres fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: python, DB: mongodb, Cloud: azure, Latency p95: 250ms, Cost: $233/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with mongodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: rust, DB: mongodb, Cloud: gcp, Latency p95: 500ms, Cost: $474/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: java, DB: mysql, Cloud: azure, Latency p95: 200ms, Cost: $222/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Single service with mysql is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: python, DB: postgres, Cloud: aws, Latency p95: 200ms, Cost: $18/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Complex architecture with 5 services needs EKS\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: rust, DB: dynamodb, Cloud: gcp, Latency p95: 250ms, Cost: $430/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with dynamodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: python, DB: postgres, Cloud: aws, Latency p95: 400ms, Cost: $233/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: go, DB: cassandra, Cloud: aws, Latency p95: 400ms, Cost: $50/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: python, DB: redis, Cloud: azure, Latency p95: 200ms, Cost: $302/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: java, DB: mongodb, Cloud: gcp, Latency p95: 200ms, Cost: $497/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"5 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: rust, DB: mongodb, Cloud: azure, Latency p95: 150ms, Cost: $63/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with mongodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: go, DB: mongodb, Cloud: gcp, Queues: rabbitmq, Latency p95: 200ms, Cost: $260/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: javascript, DB: cassandra, Cloud: aws, Queues: rabbitmq, Latency p95: 100ms, Cost: $305/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"amazon_mq\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: java, DB: mysql, Cloud: aws, Queues: redis, Latency p95: 250ms, Cost: $323/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: python, DB: mysql, Cloud: aws, Latency p95: 500ms, Cost: $48/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: rust, DB: documentdb, Cloud: aws, Latency p95: 200ms, Cost: $436/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with documentdb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: python, DB: cassandra, Cloud: azure, GPU: required, Latency p95: 250ms, Cost: $214/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"6 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: typescript, DB: mongodb, Cloud: azure, Latency p95: 100ms, Cost: $16/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Moderate complexity with mongodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: go, DB: cassandra, Cloud: aws, Queues: redis, Latency p95: 300ms, Cost: $257/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: rust, DB: postgres, Cloud: aws, Latency p95: 500ms, Cost: $323/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 3 services\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: typescript, DB: mysql, Cloud: azure, Latency p95: 400ms, Cost: $100/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"4 services with mysql fit well in ECS containers\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: javascript, DB: mongodb, Cloud: azure, Latency p95: 300ms, Cost: $371/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 5 services needs EKS\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend], Language: java, DB: cassandra, Cloud: gcp, Latency p95: 500ms, Cost: $196/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"keyspaces\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Simple API with cassandra benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: python, DB: mysql, Cloud: azure, Latency p95: 50ms, Cost: $16/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: python, DB: documentdb, Cloud: azure, Latency p95: 200ms, Cost: $239/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: typescript, DB: postgres, Cloud: aws, Queues: sqs, Latency p95: 400ms, Cost: $321/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 3 services\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: typescript, DB: mongodb, Cloud: aws, Latency p95: 200ms, Cost: $50/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with mongodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: typescript, DB: mongodb, Cloud: azure, Latency p95: 100ms, Cost: $409/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with mongodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: go, DB: mongodb, Cloud: gcp, Queues: sqs, Latency p95: 200ms, Cost: $384/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with mongodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: go, DB: documentdb, Cloud: aws, Latency p95: 50ms, Cost: $87/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: rust, DB: documentdb, Cloud: azure, GPU: required, Latency p95: 200ms, Cost: $252/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"3 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"3 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: typescript, DB: postgres, Cloud: azure, Scheduled: true, Latency p95: 100ms, Cost: $79/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Simple API with postgres benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: rust, DB: dynamodb, Cloud: gcp, Latency p95: 250ms, Cost: $304/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: javascript, DB: cassandra, Cloud: aws, Latency p95: 400ms, Cost: $281/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: go, DB: mysql, Cloud: aws, Latency p95: 500ms, Cost: $308/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with mysql suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: rust, DB: postgres, Cloud: azure, GPU: required, Latency p95: 250ms, Cost: $147/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"3 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: javascript, DB: dynamodb, Cloud: gcp, Queues: redis, Latency p95: 100ms, Cost: $121/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with dynamodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: go, DB: cassandra, Cloud: gcp, Queues: sqs, Latency p95: 400ms, Cost: $384/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with cassandra fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: javascript, DB: redis, Cloud: azure, Latency p95: 100ms, Cost: $193/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: javascript, DB: redis, Cloud: gcp, Latency p95: 50ms, Cost: $337/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with redis suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: java, DB: dynamodb, Cloud: azure, Latency p95: 400ms, Cost: $23/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Complex architecture with 5 services needs EKS\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: rust, DB: mysql, Cloud: gcp, Latency p95: 50ms, Cost: $338/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 5 services needs EKS\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: java, DB: documentdb, Cloud: gcp, Queues: redis, Latency p95: 150ms, Cost: $446/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 5 services needs EKS\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: java, DB: documentdb, Cloud: azure, Queues: redis, Latency p95: 500ms, Cost: $147/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"6 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: typescript, DB: documentdb, Cloud: azure, Latency p95: 200ms, Cost: $249/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with documentdb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: typescript, DB: mysql, Cloud: azure, Latency p95: 100ms, Cost: $80/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"4 services with mysql fit well in ECS containers\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: rust, DB: mongodb, Cloud: azure, Queues: sqs, Latency p95: 250ms, Cost: $38/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"5 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: python, DB: postgres, Cloud: gcp, GPU: required, Latency p95: 150ms, Cost: $308/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"4 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"4 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: python, DB: mongodb, Cloud: aws, Latency p95: 200ms, Cost: $71/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: python, DB: postgres, Cloud: azure, Queues: redis, Latency p95: 200ms, Cost: $357/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: go, DB: dynamodb, Cloud: aws, Queues: rabbitmq, Latency p95: 150ms, Cost: $429/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"amazon_mq\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: python, DB: dynamodb, Cloud: azure, Latency p95: 50ms, Cost: $71/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: java, DB: mongodb, Cloud: aws, Latency p95: 300ms, Cost: $88/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with mongodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: java, DB: cassandra, Cloud: gcp, Latency p95: 500ms, Cost: $75/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"keyspaces\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: go, DB: postgres, Cloud: aws, Latency p95: 250ms, Cost: $68/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: javascript, DB: documentdb, Cloud: gcp, Latency p95: 250ms, Cost: $94/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Complex architecture with 5 services needs EKS\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend], Language: rust, DB: documentdb, Cloud: gcp, GPU: required, Latency p95: 500ms, Cost: $348/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"1 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: java, DB: mysql, Cloud: aws, Queues: sqs, Latency p95: 400ms, Cost: $354/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: javascript, DB: mysql, Cloud: aws, Latency p95: 200ms, Cost: $98/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: rust, DB: cassandra, Cloud: aws, Queues: redis, Latency p95: 100ms, Cost: $106/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"keyspaces\", \"eventbridge\", \"elasticache\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: java, DB: mongodb, Cloud: aws, Latency p95: 250ms, Cost: $60/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"3 services with mongodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: go, DB: postgres, Cloud: azure, Queues: sqs, Latency p95: 500ms, Cost: $156/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: typescript, DB: dynamodb, Cloud: azure, Latency p95: 50ms, Cost: $348/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with dynamodb benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: java, DB: documentdb, Cloud: aws, Queues: redis, Latency p95: 50ms, Cost: $126/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"2 services with documentdb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: javascript, DB: dynamodb, Cloud: aws, Latency p95: 300ms, Cost: $270/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with dynamodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: java, DB: redis, Cloud: azure, Latency p95: 250ms, Cost: $156/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: java, DB: documentdb, Cloud: gcp, Queues: redis, Latency p95: 500ms, Cost: $227/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with documentdb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: javascript, DB: cassandra, Cloud: gcp, Latency p95: 500ms, Cost: $48/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: go, DB: mysql, Cloud: aws, Latency p95: 100ms, Cost: $204/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 3 services\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: go, DB: redis, Cloud: azure, Latency p95: 300ms, Cost: $137/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: java, DB: mysql, Cloud: gcp, Latency p95: 300ms, Cost: $328/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: javascript, DB: redis, Cloud: gcp, Latency p95: 250ms, Cost: $311/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: python, DB: documentdb, Cloud: aws, Latency p95: 500ms, Cost: $399/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: rust, DB: mysql, Cloud: azure, Latency p95: 200ms, Cost: $481/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"lift_and_shift\", \"components\": [\"alb\", \"ec2\", \"efs\", \"elasticache\", \"rds\"], \"topology\": \"1 services with lift_and_shift pattern on azure\", \"scaling_strategy\": \"vertical_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Monolith application suits EC2-based deployment\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: typescript, DB: cassandra, Cloud: aws, Scheduled: true, Latency p95: 250ms, Cost: $68/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"keyspaces\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Simple API with cassandra benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: rust, DB: mysql, Cloud: azure, Latency p95: 400ms, Cost: $109/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with mysql suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: go, DB: mysql, Cloud: gcp, Latency p95: 200ms, Cost: $327/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with mysql fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: python, DB: cassandra, Cloud: aws, Latency p95: 100ms, Cost: $470/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"keyspaces\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: rust, DB: cassandra, Cloud: aws, Latency p95: 50ms, Cost: $252/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: javascript, DB: documentdb, Cloud: azure, Latency p95: 300ms, Cost: $421/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"8 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: rust, DB: redis, Cloud: azure, Queues: kafka, Latency p95: 200ms, Cost: $83/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"3 services with event_driven pattern on azure\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Asynchronous workflows benefit from event-driven design\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: python, DB: redis, Cloud: gcp, GPU: required, Latency p95: 300ms, Cost: $323/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"4 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: rust, DB: mysql, Cloud: azure, Latency p95: 250ms, Cost: $253/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with mysql suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: go, DB: cassandra, Cloud: aws, Latency p95: 150ms, Cost: $292/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with cassandra suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: typescript, DB: mongodb, Cloud: azure, Latency p95: 50ms, Cost: $146/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: python, DB: postgres, Cloud: azure, Latency p95: 300ms, Cost: $300/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with postgres suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: go, DB: dynamodb, Cloud: gcp, Queues: sqs, Latency p95: 400ms, Cost: $312/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with dynamodb benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend], Language: go, DB: redis, Cloud: aws, Latency p95: 500ms, Cost: $155/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"redis\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: python, DB: mysql, Cloud: aws, Queues: sqs, Latency p95: 300ms, Cost: $41/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: javascript, DB: mysql, Cloud: aws, Latency p95: 500ms, Cost: $205/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: javascript, DB: postgres, Cloud: aws, Latency p95: 300ms, Cost: $11/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Moderate complexity with postgres suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend], Language: java, DB: redis, Cloud: gcp, Latency p95: 500ms, Cost: $197/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Simple API with redis benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend], Language: python, DB: mongodb, Cloud: azure, Latency p95: 250ms, Cost: $463/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Single service with mongodb is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: java, DB: mongodb, Cloud: azure, Queues: kafka, GPU: required, Latency p95: 150ms, Cost: $12/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"msk\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"4 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: java, DB: mysql, Cloud: aws, Latency p95: 100ms, Cost: $238/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"3 services with mysql fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: typescript, DB: postgres, Cloud: gcp, Queues: kafka, Latency p95: 500ms, Cost: $467/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\", \"kinesis\"], \"topology\": \"3 services with event_driven pattern on gcp\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Real-time streaming with kafka needs event-driven pattern\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: typescript, DB: redis, Cloud: aws, Latency p95: 100ms, Cost: $467/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"redis\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: java, DB: dynamodb, Cloud: aws, Latency p95: 200ms, Cost: $498/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with dynamodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: typescript, DB: dynamodb, Cloud: aws, Latency p95: 250ms, Cost: $442/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with dynamodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: python, DB: documentdb, Cloud: gcp, Latency p95: 500ms, Cost: $149/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: rust, DB: mysql, Cloud: azure, Latency p95: 250ms, Cost: $65/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: java, DB: dynamodb, Cloud: gcp, Latency p95: 50ms, Cost: $297/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend], Language: java, DB: mongodb, Cloud: azure, Latency p95: 250ms, Cost: $241/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: rust, DB: documentdb, Cloud: aws, Latency p95: 50ms, Cost: $339/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Single service with documentdb is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: javascript, DB: mongodb, Cloud: gcp, Scheduled: true, Latency p95: 400ms, Cost: $101/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Single service with mongodb is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: typescript, DB: mysql, Cloud: azure, Latency p95: 500ms, Cost: $465/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: javascript, DB: cassandra, Cloud: gcp, Latency p95: 300ms, Cost: $188/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with cassandra suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: typescript, DB: mysql, Cloud: azure, Latency p95: 250ms, Cost: $346/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with mysql suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: go, DB: dynamodb, Cloud: azure, GPU: required, Latency p95: 250ms, Cost: $47/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"5 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: javascript, DB: cassandra, Cloud: aws, Scheduled: true, Latency p95: 200ms, Cost: $143/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"keyspaces\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Single service with cassandra is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: python, DB: mysql, Cloud: aws, GPU: required, Latency p95: 500ms, Cost: $238/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"3 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: typescript, DB: postgres, Cloud: aws, Latency p95: 150ms, Cost: $490/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: javascript, DB: documentdb, Cloud: gcp, GPU: required, Latency p95: 150ms, Cost: $122/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"2 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"2 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: javascript, DB: postgres, Cloud: gcp, Latency p95: 50ms, Cost: $261/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with postgres fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: rust, DB: documentdb, Cloud: aws, Queues: rabbitmq, Latency p95: 400ms, Cost: $244/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with documentdb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: java, DB: postgres, Cloud: azure, Queues: sqs, Latency p95: 400ms, Cost: $115/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Simple API with postgres benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: python, DB: mysql, Cloud: azure, Latency p95: 500ms, Cost: $370/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with mysql fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: java, DB: mysql, Cloud: aws, Latency p95: 400ms, Cost: $101/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"2 services with mysql fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: go, DB: cassandra, Cloud: azure, Latency p95: 150ms, Cost: $436/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"3 services with cassandra fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: go, DB: documentdb, Cloud: azure, Latency p95: 200ms, Cost: $25/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: java, DB: redis, Cloud: azure, Latency p95: 300ms, Cost: $127/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 3 services\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: python, DB: redis, Cloud: azure, Latency p95: 400ms, Cost: $189/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: javascript, DB: mongodb, Cloud: azure, Queues: sqs, Latency p95: 50ms, Cost: $245/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: typescript, DB: cassandra, Cloud: azure, Latency p95: 400ms, Cost: $288/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with cassandra suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: python, DB: redis, Cloud: aws, Latency p95: 500ms, Cost: $153/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"redis\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: python, DB: mysql, Cloud: gcp, Latency p95: 200ms, Cost: $89/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"5 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: rust, DB: documentdb, Cloud: azure, Latency p95: 150ms, Cost: $86/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: javascript, DB: dynamodb, Cloud: aws, GPU: required, Latency p95: 400ms, Cost: $184/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"3 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: go, DB: mysql, Cloud: gcp, Latency p95: 250ms, Cost: $459/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: go, DB: mongodb, Cloud: azure, GPU: required, Latency p95: 200ms, Cost: $380/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: python, DB: dynamodb, Cloud: aws, Queues: sqs, Latency p95: 250ms, Cost: $410/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: python, DB: mysql, Cloud: gcp, Queues: rabbitmq, Latency p95: 500ms, Cost: $289/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with mysql suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: python, DB: cassandra, Cloud: aws, Latency p95: 150ms, Cost: $494/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"4 services with cassandra fit well in ECS containers\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: go, DB: documentdb, Cloud: gcp, Latency p95: 500ms, Cost: $213/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with documentdb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: go, DB: mysql, Cloud: azure, Queues: kafka, Latency p95: 100ms, Cost: $340/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\", \"kinesis\"], \"topology\": \"1 services with event_driven pattern on azure\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Event-based processing with mysql suits MSK and Lambda\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: python, DB: mysql, Cloud: aws, Latency p95: 200ms, Cost: $143/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"3 services with mysql fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: rust, DB: mysql, Cloud: gcp, Latency p95: 500ms, Cost: $458/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Single service with mysql is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: typescript, DB: cassandra, Cloud: gcp, Latency p95: 100ms, Cost: $462/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"keyspaces\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Single service with cassandra is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: rust, DB: mongodb, Cloud: aws, Latency p95: 200ms, Cost: $432/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with mongodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: go, DB: postgres, Cloud: gcp, Latency p95: 500ms, Cost: $315/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with postgres suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: go, DB: mysql, Cloud: azure, Queues: kafka, GPU: required, Latency p95: 200ms, Cost: $80/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"msk\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"4 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Complex architecture with 4 services needs EKS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: typescript, DB: redis, Cloud: azure, Latency p95: 150ms, Cost: $348/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with redis fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: java, DB: postgres, Cloud: aws, Latency p95: 50ms, Cost: $220/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with postgres suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: go, DB: mongodb, Cloud: gcp, Latency p95: 400ms, Cost: $243/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 6 services needs EKS\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: typescript, DB: mysql, Cloud: gcp, Latency p95: 100ms, Cost: $191/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with mysql suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: javascript, DB: mongodb, Cloud: azure, Queues: rabbitmq, Latency p95: 300ms, Cost: $205/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with mongodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: javascript, DB: redis, Cloud: gcp, Latency p95: 100ms, Cost: $408/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: typescript, DB: documentdb, Cloud: aws, Latency p95: 400ms, Cost: $373/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend], Language: java, DB: cassandra, Cloud: gcp, Queues: kafka, Latency p95: 400ms, Cost: $314/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"keyspaces\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"1 services with event_driven pattern on gcp\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Real-time streaming with kafka needs event-driven pattern\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: python, DB: mysql, Cloud: aws, Latency p95: 300ms, Cost: $19/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: java, DB: mongodb, Cloud: gcp, GPU: required, Latency p95: 300ms, Cost: $207/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 8 services needs EKS\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: rust, DB: dynamodb, Cloud: aws, Queues: kafka, Latency p95: 150ms, Cost: $342/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"3 services with event_driven pattern on aws\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Kafka integration indicates event-driven architecture\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: typescript, DB: mysql, Cloud: azure, Queues: kafka, Latency p95: 100ms, Cost: $152/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\", \"kinesis\"], \"topology\": \"2 services with event_driven pattern on azure\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Real-time streaming with kafka needs event-driven pattern\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: go, DB: cassandra, Cloud: azure, Queues: kafka, GPU: required, Scheduled: true, Latency p95: 150ms, Cost: $229/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"msk\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"1 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: java, DB: mysql, Cloud: gcp, Latency p95: 200ms, Cost: $38/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Moderate complexity with mysql suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: typescript, DB: postgres, Cloud: aws, Latency p95: 200ms, Cost: $499/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with postgres benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: typescript, DB: mongodb, Cloud: azure, Queues: kafka, Latency p95: 100ms, Cost: $122/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"3 services with event_driven pattern on azure\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Kafka integration indicates event-driven architecture\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: javascript, DB: postgres, Cloud: azure, Latency p95: 400ms, Cost: $344/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Single service with postgres is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: java, DB: cassandra, Cloud: gcp, Latency p95: 500ms, Cost: $84/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with cassandra suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: typescript, DB: dynamodb, Cloud: gcp, Latency p95: 500ms, Cost: $398/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with dynamodb benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: go, DB: dynamodb, Cloud: aws, Latency p95: 200ms, Cost: $18/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Complex architecture with 5 services needs EKS\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: python, DB: postgres, Cloud: azure, Queues: rabbitmq, Latency p95: 250ms, Cost: $140/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: rust, DB: mongodb, Cloud: aws, Latency p95: 250ms, Cost: $72/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with mongodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: python, DB: documentdb, Cloud: azure, Queues: kafka, GPU: required, Latency p95: 500ms, Cost: $22/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"msk\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"2 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Complex architecture with 2 services needs EKS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: python, DB: postgres, Cloud: gcp, Queues: sqs, Latency p95: 150ms, Cost: $70/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"3 services with postgres fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: rust, DB: mongodb, Cloud: azure, Latency p95: 150ms, Cost: $480/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with mongodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: javascript, DB: mongodb, Cloud: aws, Queues: rabbitmq, Latency p95: 500ms, Cost: $350/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: python, DB: mysql, Cloud: aws, Scheduled: true, Latency p95: 150ms, Cost: $152/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: python, DB: mongodb, Cloud: aws, Latency p95: 250ms, Cost: $222/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: javascript, DB: documentdb, Cloud: gcp, Queues: redis, Latency p95: 150ms, Cost: $417/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"elasticache\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with documentdb benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: javascript, DB: mysql, Cloud: gcp, Latency p95: 250ms, Cost: $97/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Complex architecture with 5 services needs EKS\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend], Language: java, DB: mongodb, Cloud: gcp, Latency p95: 200ms, Cost: $481/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: java, DB: cassandra, Cloud: aws, Latency p95: 400ms, Cost: $207/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with cassandra suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: rust, DB: mysql, Cloud: gcp, Scheduled: true, Latency p95: 400ms, Cost: $292/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: python, DB: postgres, Cloud: azure, Latency p95: 150ms, Cost: $450/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: typescript, DB: redis, Cloud: gcp, Latency p95: 300ms, Cost: $36/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: javascript, DB: documentdb, Cloud: azure, Queues: sqs, Latency p95: 250ms, Cost: $41/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"2 services with documentdb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: go, DB: postgres, Cloud: azure, Queues: sqs, Latency p95: 250ms, Cost: $289/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: typescript, DB: cassandra, Cloud: azure, Latency p95: 200ms, Cost: $199/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with cassandra suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: rust, DB: dynamodb, Cloud: aws, Latency p95: 200ms, Cost: $91/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with dynamodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: javascript, DB: mongodb, Cloud: azure, Latency p95: 150ms, Cost: $425/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with mongodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: go, DB: dynamodb, Cloud: azure, Latency p95: 400ms, Cost: $441/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 8 services needs EKS\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: rust, DB: redis, Cloud: azure, Queues: rabbitmq, Latency p95: 50ms, Cost: $403/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"amazon_mq\", \"s3\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: java, DB: cassandra, Cloud: azure, Latency p95: 300ms, Cost: $338/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"3 services with cassandra fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: go, DB: mongodb, Cloud: azure, Latency p95: 500ms, Cost: $55/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: java, DB: cassandra, Cloud: gcp, Latency p95: 50ms, Cost: $394/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: go, DB: cassandra, Cloud: gcp, Queues: sqs, Latency p95: 250ms, Cost: $139/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"4 services with cassandra fit well in ECS containers\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: go, DB: dynamodb, Cloud: gcp, Latency p95: 500ms, Cost: $218/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: go, DB: mysql, Cloud: aws, Scheduled: true, Latency p95: 500ms, Cost: $280/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: typescript, DB: dynamodb, Cloud: azure, Latency p95: 200ms, Cost: $282/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: go, DB: redis, Cloud: azure, Latency p95: 300ms, Cost: $56/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with redis suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: python, DB: mongodb, Cloud: aws, Queues: redis, GPU: required, Latency p95: 50ms, Cost: $153/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"3 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Complex architecture with 3 services needs EKS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: rust, DB: mysql, Cloud: aws, Latency p95: 250ms, Cost: $78/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: rust, DB: cassandra, Cloud: azure, Queues: kafka, Latency p95: 150ms, Cost: $209/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"keyspaces\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"1 services with event_driven pattern on azure\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Real-time streaming with kafka needs event-driven pattern\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: typescript, DB: mysql, Cloud: gcp, Scheduled: true, Latency p95: 400ms, Cost: $164/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: typescript, DB: mongodb, Cloud: azure, Queues: sqs, Latency p95: 50ms, Cost: $402/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: java, DB: mongodb, Cloud: aws, Latency p95: 500ms, Cost: $430/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"5 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: typescript, DB: dynamodb, Cloud: azure, Latency p95: 150ms, Cost: $39/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"4 services with dynamodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: java, DB: postgres, Cloud: gcp, Latency p95: 250ms, Cost: $97/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"2 services with postgres fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: java, DB: documentdb, Cloud: azure, Latency p95: 500ms, Cost: $469/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with documentdb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: go, DB: postgres, Cloud: azure, Latency p95: 400ms, Cost: $89/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 3 services\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: java, DB: postgres, Cloud: gcp, Queues: rabbitmq, Latency p95: 500ms, Cost: $138/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"2 services with postgres fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: python, DB: mongodb, Cloud: gcp, Latency p95: 500ms, Cost: $219/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: rust, DB: mongodb, Cloud: aws, Queues: rabbitmq, Latency p95: 250ms, Cost: $405/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"4 services with mongodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: javascript, DB: mysql, Cloud: azure, Latency p95: 300ms, Cost: $409/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: go, DB: dynamodb, Cloud: gcp, Scheduled: true, Latency p95: 400ms, Cost: $125/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Simple API with dynamodb benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: go, DB: postgres, Cloud: aws, Queues: redis, Latency p95: 400ms, Cost: $59/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: go, DB: documentdb, Cloud: azure, Latency p95: 500ms, Cost: $380/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with documentdb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: go, DB: cassandra, Cloud: aws, Latency p95: 200ms, Cost: $20/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: python, DB: dynamodb, Cloud: aws, Latency p95: 400ms, Cost: $124/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"3 services with dynamodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: python, DB: redis, Cloud: gcp, Latency p95: 250ms, Cost: $380/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with redis benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: typescript, DB: redis, Cloud: aws, Queues: sqs, Latency p95: 100ms, Cost: $134/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Single service with redis is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"redis\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: java, DB: redis, Cloud: azure, Latency p95: 150ms, Cost: $146/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: typescript, DB: mysql, Cloud: azure, Latency p95: 500ms, Cost: $215/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with mysql benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: javascript, DB: dynamodb, Cloud: aws, Queues: kafka, GPU: required, Latency p95: 100ms, Cost: $450/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"msk\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"4 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 4 services needs EKS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: java, DB: cassandra, Cloud: gcp, Queues: rabbitmq, Latency p95: 150ms, Cost: $356/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"amazon_mq\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: typescript, DB: mongodb, Cloud: aws, Latency p95: 150ms, Cost: $169/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with mongodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: python, DB: mongodb, Cloud: gcp, Queues: kafka, Latency p95: 250ms, Cost: $385/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"1 services with event_driven pattern on gcp\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Asynchronous workflows benefit from event-driven design\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: rust, DB: postgres, Cloud: azure, Latency p95: 200ms, Cost: $257/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with postgres fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: java, DB: mongodb, Cloud: aws, Latency p95: 50ms, Cost: $95/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with mongodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: python, DB: redis, Cloud: azure, Latency p95: 300ms, Cost: $44/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: java, DB: dynamodb, Cloud: aws, Queues: redis, Latency p95: 200ms, Cost: $205/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with dynamodb benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: rust, DB: cassandra, Cloud: azure, Latency p95: 150ms, Cost: $324/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"keyspaces\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: go, DB: postgres, Cloud: aws, Latency p95: 500ms, Cost: $416/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: rust, DB: documentdb, Cloud: gcp, Queues: rabbitmq, Latency p95: 50ms, Cost: $287/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"3 services with documentdb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: python, DB: dynamodb, Cloud: aws, Latency p95: 50ms, Cost: $444/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: python, DB: documentdb, Cloud: azure, Queues: rabbitmq, Latency p95: 100ms, Cost: $138/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"amazon_mq\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: javascript, DB: documentdb, Cloud: azure, Queues: sqs, Latency p95: 50ms, Cost: $139/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: go, DB: redis, Cloud: aws, Latency p95: 250ms, Cost: $161/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"5 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"redis\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: java, DB: postgres, Cloud: gcp, GPU: required, Latency p95: 50ms, Cost: $372/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"1 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 1 services needs EKS\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: typescript, DB: mysql, Cloud: azure, Latency p95: 400ms, Cost: $184/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: java, DB: mysql, Cloud: aws, Latency p95: 400ms, Cost: $333/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with mysql benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: python, DB: mongodb, Cloud: azure, Latency p95: 50ms, Cost: $474/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with mongodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: java, DB: postgres, Cloud: aws, Latency p95: 300ms, Cost: $393/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: go, DB: documentdb, Cloud: aws, Queues: sqs, Latency p95: 250ms, Cost: $438/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with documentdb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: typescript, DB: mysql, Cloud: gcp, Queues: redis, Latency p95: 100ms, Cost: $136/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: javascript, DB: dynamodb, Cloud: aws, Latency p95: 100ms, Cost: $126/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Single service with dynamodb is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: typescript, DB: mysql, Cloud: gcp, Latency p95: 250ms, Cost: $27/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"4 services with mysql fit well in ECS containers\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: java, DB: dynamodb, Cloud: azure, Queues: redis, Latency p95: 250ms, Cost: $166/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: javascript, DB: cassandra, Cloud: aws, Latency p95: 50ms, Cost: $271/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with cassandra fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: javascript, DB: documentdb, Cloud: aws, Queues: redis, Latency p95: 150ms, Cost: $265/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"elasticache\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Single service with documentdb is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: javascript, DB: cassandra, Cloud: azure, Latency p95: 100ms, Cost: $219/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with cassandra fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: go, DB: mysql, Cloud: gcp, Latency p95: 200ms, Cost: $76/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: go, DB: postgres, Cloud: azure, Latency p95: 300ms, Cost: $304/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: javascript, DB: cassandra, Cloud: azure, Queues: sqs, Latency p95: 100ms, Cost: $363/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with cassandra fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: java, DB: dynamodb, Cloud: aws, Latency p95: 100ms, Cost: $377/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with dynamodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: go, DB: mysql, Cloud: gcp, Scheduled: true, Latency p95: 50ms, Cost: $336/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: javascript, DB: mysql, Cloud: aws, Queues: kafka, Latency p95: 200ms, Cost: $292/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\", \"kinesis\"], \"topology\": \"2 services with event_driven pattern on aws\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Asynchronous workflows benefit from event-driven design\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: java, DB: cassandra, Cloud: gcp, Queues: kafka, Latency p95: 100ms, Cost: $260/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"keyspaces\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"1 services with event_driven pattern on gcp\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Event-based processing with cassandra suits MSK and Lambda\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: typescript, DB: documentdb, Cloud: gcp, Latency p95: 50ms, Cost: $433/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: typescript, DB: documentdb, Cloud: aws, Queues: redis, Latency p95: 100ms, Cost: $156/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: rust, DB: cassandra, Cloud: gcp, Latency p95: 400ms, Cost: $194/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"keyspaces\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Single service with cassandra is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: go, DB: dynamodb, Cloud: aws, Queues: rabbitmq, Latency p95: 250ms, Cost: $382/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: typescript, DB: postgres, Cloud: gcp, Latency p95: 300ms, Cost: $408/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: go, DB: mysql, Cloud: aws, Queues: kafka, Latency p95: 300ms, Cost: $218/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\", \"kinesis\"], \"topology\": \"1 services with event_driven pattern on aws\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Asynchronous workflows benefit from event-driven design\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: javascript, DB: dynamodb, Cloud: aws, Latency p95: 300ms, Cost: $292/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: javascript, DB: mongodb, Cloud: gcp, GPU: required, Latency p95: 200ms, Cost: $101/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"2 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"2 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: java, DB: mongodb, Cloud: azure, Queues: redis, Latency p95: 250ms, Cost: $303/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: typescript, DB: dynamodb, Cloud: gcp, Queues: kafka, Scheduled: true, Latency p95: 500ms, Cost: $291/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"1 services with event_driven pattern on gcp\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Event-based processing with dynamodb suits MSK and Lambda\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: javascript, DB: mongodb, Cloud: aws, Latency p95: 150ms, Cost: $494/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: go, DB: mysql, Cloud: azure, Latency p95: 50ms, Cost: $376/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with mysql suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: typescript, DB: mysql, Cloud: aws, Latency p95: 400ms, Cost: $432/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"4 services with mysql fit well in ECS containers\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: go, DB: dynamodb, Cloud: gcp, Queues: sqs, Latency p95: 100ms, Cost: $357/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 3 services\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: python, DB: postgres, Cloud: aws, Latency p95: 150ms, Cost: $473/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: go, DB: redis, Cloud: aws, Queues: sqs, Latency p95: 50ms, Cost: $401/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with redis suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"redis\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: go, DB: postgres, Cloud: azure, Latency p95: 300ms, Cost: $441/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with postgres benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: rust, DB: redis, Cloud: gcp, Latency p95: 100ms, Cost: $449/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: go, DB: documentdb, Cloud: aws, Queues: sqs, Latency p95: 250ms, Cost: $29/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: python, DB: cassandra, Cloud: gcp, Latency p95: 150ms, Cost: $394/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: java, DB: dynamodb, Cloud: aws, Queues: rabbitmq, Latency p95: 150ms, Cost: $240/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: python, DB: redis, Cloud: azure, Latency p95: 250ms, Cost: $199/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Single service with redis is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: python, DB: postgres, Cloud: gcp, Latency p95: 150ms, Cost: $102/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"3 services with postgres fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: go, DB: documentdb, Cloud: aws, Latency p95: 300ms, Cost: $383/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: javascript, DB: mongodb, Cloud: aws, Latency p95: 100ms, Cost: $85/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"8 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: rust, DB: mongodb, Cloud: gcp, Latency p95: 250ms, Cost: $81/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: python, DB: redis, Cloud: azure, Latency p95: 500ms, Cost: $80/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"4 services with redis fit well in ECS containers\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: rust, DB: documentdb, Cloud: aws, Queues: rabbitmq, Latency p95: 100ms, Cost: $339/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"lift_and_shift\", \"components\": [\"alb\", \"ec2\", \"efs\", \"amazon_mq\", \"elasticache\", \"documentdb\", \"rds\"], \"topology\": \"1 services with lift_and_shift pattern on aws\", \"scaling_strategy\": \"vertical_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Monolith application suits EC2-based deployment\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: go, DB: documentdb, Cloud: gcp, Latency p95: 250ms, Cost: $483/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Complex architecture with 5 services needs EKS\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: typescript, DB: postgres, Cloud: aws, Latency p95: 500ms, Cost: $165/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: javascript, DB: documentdb, Cloud: gcp, Latency p95: 300ms, Cost: $218/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: typescript, DB: mysql, Cloud: gcp, Latency p95: 500ms, Cost: $213/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: java, DB: mysql, Cloud: aws, GPU: required, Latency p95: 200ms, Cost: $487/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"3 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: typescript, DB: cassandra, Cloud: aws, Latency p95: 500ms, Cost: $410/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"6 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: rust, DB: redis, Cloud: gcp, Latency p95: 500ms, Cost: $375/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with redis suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: javascript, DB: cassandra, Cloud: azure, Latency p95: 400ms, Cost: $120/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 3 services\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: typescript, DB: mongodb, Cloud: azure, Latency p95: 250ms, Cost: $48/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: typescript, DB: mysql, Cloud: azure, Latency p95: 250ms, Cost: $404/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: python, DB: cassandra, Cloud: azure, Queues: sqs, Latency p95: 150ms, Cost: $486/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"8 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: javascript, DB: redis, Cloud: gcp, Queues: sqs, Latency p95: 200ms, Cost: $417/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: rust, DB: redis, Cloud: aws, Latency p95: 200ms, Cost: $193/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with redis suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"redis\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: go, DB: mysql, Cloud: aws, Queues: redis, Latency p95: 250ms, Cost: $453/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with mysql benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: go, DB: redis, Cloud: aws, Latency p95: 250ms, Cost: $243/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"redis\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: python, DB: dynamodb, Cloud: aws, Queues: rabbitmq, Latency p95: 500ms, Cost: $357/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"amazon_mq\", \"s3\", \"dynamodb\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: java, DB: mysql, Cloud: aws, Latency p95: 100ms, Cost: $230/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, auth, worker], Language: javascript, DB: dynamodb, Cloud: gcp, Latency p95: 250ms, Cost: $422/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: go, DB: postgres, Cloud: azure, Queues: redis, Latency p95: 50ms, Cost: $20/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Moderate complexity with postgres suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: javascript, DB: redis, Cloud: azure, Queues: rabbitmq, Latency p95: 250ms, Cost: $252/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"4 services with redis fit well in ECS containers\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: go, DB: mongodb, Cloud: gcp, Queues: rabbitmq, Latency p95: 100ms, Cost: $154/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"amazon_mq\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: python, DB: postgres, Cloud: aws, Latency p95: 150ms, Cost: $71/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: typescript, DB: postgres, Cloud: aws, Latency p95: 300ms, Cost: $458/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"3 services with postgres fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: java, DB: postgres, Cloud: aws, Latency p95: 500ms, Cost: $467/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: java, DB: redis, Cloud: aws, Latency p95: 200ms, Cost: $447/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"aws\", \"database\": \"redis\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: java, DB: redis, Cloud: azure, GPU: required, Latency p95: 200ms, Cost: $11/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"2 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: javascript, DB: mysql, Cloud: azure, Latency p95: 50ms, Cost: $63/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Complex architecture with 5 services needs EKS\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: rust, DB: dynamodb, Cloud: aws, Queues: kafka, Latency p95: 400ms, Cost: $57/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"4 services with event_driven pattern on aws\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Event-based processing with dynamodb suits MSK and Lambda\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: javascript, DB: mysql, Cloud: gcp, Latency p95: 50ms, Cost: $293/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: typescript, DB: cassandra, Cloud: gcp, Latency p95: 150ms, Cost: $120/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 3 services\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: rust, DB: cassandra, Cloud: gcp, Latency p95: 300ms, Cost: $176/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with cassandra suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: javascript, DB: mysql, Cloud: gcp, Latency p95: 250ms, Cost: $268/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with mysql benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mysql\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: rust, DB: redis, Cloud: gcp, GPU: required, Latency p95: 50ms, Cost: $496/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"2 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: javascript, DB: dynamodb, Cloud: aws, Latency p95: 400ms, Cost: $159/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: javascript, DB: dynamodb, Cloud: gcp, Latency p95: 50ms, Cost: $18/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Single service with dynamodb is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: go, DB: mongodb, Cloud: azure, Queues: redis, Latency p95: 400ms, Cost: $432/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"elasticache\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: typescript, DB: mongodb, Cloud: azure, Latency p95: 500ms, Cost: $428/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"3 services with mongodb fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker, scheduler, notifications], Language: javascript, DB: cassandra, Cloud: gcp, Latency p95: 300ms, Cost: $142/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"5 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: rust, DB: mongodb, Cloud: gcp, Latency p95: 250ms, Cost: $233/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: typescript, DB: mysql, Cloud: aws, GPU: required, Latency p95: 250ms, Cost: $51/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"2 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: typescript, DB: documentdb, Cloud: gcp, Latency p95: 200ms, Cost: $462/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with documentdb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: rust, DB: postgres, Cloud: gcp, Latency p95: 300ms, Cost: $149/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"gcp\", \"database\": \"postgres\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, payments], Language: python, DB: redis, Cloud: gcp, Latency p95: 100ms, Cost: $386/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with redis suits ECS orchestration\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, web], Language: typescript, DB: cassandra, Cloud: gcp, Latency p95: 400ms, Cost: $179/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with cassandra suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users], Language: javascript, DB: redis, Cloud: gcp, Latency p95: 250ms, Cost: $176/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: rust, DB: redis, Cloud: azure, Latency p95: 200ms, Cost: $381/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web, api, worker], Language: go, DB: mongodb, Cloud: azure, Queues: sqs, Latency p95: 200ms, Cost: $232/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api], Language: javascript, DB: mongodb, Cloud: gcp, Latency p95: 300ms, Cost: $363/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"lift_and_shift\", \"components\": [\"alb\", \"ec2\", \"efs\", \"elasticache\", \"documentdb\", \"rds\"], \"topology\": \"1 services with lift_and_shift pattern on gcp\", \"scaling_strategy\": \"vertical_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Monolith application suits EC2-based deployment\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: javascript, DB: mongodb, Cloud: azure, Queues: kafka, GPU: required, Latency p95: 250ms, Cost: $49/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"msk\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"4 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"low\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"mongodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: javascript, DB: mysql, Cloud: azure, Latency p95: 500ms, Cost: $234/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"rds\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Low cost and scalability needs make Lambda the best choice\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend], Language: go, DB: cassandra, Cloud: azure, Latency p95: 100ms, Cost: $336/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"keyspaces\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Simple API with cassandra benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: rust, DB: redis, Cloud: aws, Queues: kafka, Latency p95: 100ms, Cost: $19/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"2 services with event_driven pattern on aws\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Asynchronous workflows benefit from event-driven design\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"redis\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: rust, DB: mongodb, Cloud: aws, Queues: redis, Latency p95: 500ms, Cost: $296/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with mongodb suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: typescript, DB: cassandra, Cloud: azure, Queues: sqs, Latency p95: 150ms, Cost: $424/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services with cassandra fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: typescript, DB: postgres, Cloud: aws, Queues: redis, Latency p95: 50ms, Cost: $59/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"postgres\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: javascript, DB: dynamodb, Cloud: azure, Latency p95: 400ms, Cost: $67/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"dynamodb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: rust, DB: redis, Cloud: gcp, Latency p95: 150ms, Cost: $185/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: rust, DB: documentdb, Cloud: gcp, Latency p95: 200ms, Cost: $496/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: go, DB: cassandra, Cloud: azure, Latency p95: 50ms, Cost: $497/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"6 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: javascript, DB: cassandra, Cloud: gcp, Latency p95: 300ms, Cost: $83/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Complex architecture with 8 services needs EKS\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: rust, DB: mysql, Cloud: azure, Latency p95: 200ms, Cost: $466/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: python, DB: cassandra, Cloud: gcp, Latency p95: 300ms, Cost: $101/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Moderate complexity with cassandra suits ECS orchestration\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: python, DB: mongodb, Cloud: aws, Latency p95: 200ms, Cost: $263/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend], Language: javascript, DB: redis, Cloud: azure, Queues: sqs, Latency p95: 150ms, Cost: $67/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on azure\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Simple API with redis benefits from serverless auto-scaling\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: go, DB: mongodb, Cloud: aws, Latency p95: 300ms, Cost: $43/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"mongodb\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: typescript, DB: redis, Cloud: gcp, GPU: required, Latency p95: 200ms, Cost: $269/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"2 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"2 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments, shipping], Language: java, DB: documentdb, Cloud: aws, Latency p95: 100ms, Cost: $90/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"6 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 6, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend], Language: java, DB: redis, Cloud: gcp, Latency p95: 100ms, Cost: $474/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Moderate complexity with redis suits ECS orchestration\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: javascript, DB: documentdb, Cloud: gcp, Latency p95: 50ms, Cost: $155/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"documentdb\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: rust, DB: redis, Cloud: gcp, Latency p95: 50ms, Cost: $62/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 2-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: rust, DB: mysql, Cloud: azure, Queues: sqs, GPU: required, Latency p95: 400ms, Cost: $170/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on azure\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"GPU workloads require EKS with specialized node groups\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders, payments], Language: rust, DB: documentdb, Cloud: gcp, Latency p95: 250ms, Cost: $348/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"documentdb\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"5 services with kubernetes pattern on gcp\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Multi-service platform benefits from Kubernetes service mesh\"}, \"inputs\": {\"service_count\": 5, \"cloud_provider\": \"gcp\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: python, DB: cassandra, Cloud: gcp, Latency p95: 400ms, Cost: $125/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"3 services with cassandra fit well in ECS containers\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: rust, DB: dynamodb, Cloud: gcp, Queues: redis, Latency p95: 200ms, Cost: $279/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"dynamodb\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Containerized 4-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker], Language: typescript, DB: redis, Cloud: azure, Latency p95: 400ms, Cost: $286/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 2 services\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [frontend, backend, gateway], Language: typescript, DB: cassandra, Cloud: gcp, Queues: redis, Latency p95: 200ms, Cost: $121/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"3 services with microservices_ecs pattern on gcp\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Containerized 3-service architecture optimal for ECS\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"gcp\", \"database\": \"cassandra\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [web], Language: java, DB: redis, Cloud: gcp, Queues: rabbitmq, Latency p95: 300ms, Cost: $40/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"amazon_mq\", \"s3\", \"dynamodb\", \"elasticache\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"low\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"redis\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: typescript, DB: redis, Cloud: azure, Latency p95: 250ms, Cost: $94/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"redis\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, users, products, orders], Language: javascript, DB: cassandra, Cloud: aws, Latency p95: 500ms, Cost: $110/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on aws\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"4 services with cassandra fit well in ECS containers\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"javascript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [gateway, auth, users, catalog, orders, payments, shipping, notifications], Language: python, DB: cassandra, Cloud: aws, Latency p95: 300ms, Cost: $113/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"kubernetes\", \"components\": [\"alb\", \"s3\", \"eks_cluster\", \"elasticache\", \"keyspaces\", \"rds\", \"karpenter\", \"sqs\"], \"topology\": \"8 services with kubernetes pattern on aws\", \"scaling_strategy\": \"kubernetes_hpa\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"8 services require Kubernetes for proper orchestration\"}, \"inputs\": {\"service_count\": 8, \"cloud_provider\": \"aws\", \"database\": \"cassandra\", \"language\": \"python\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, worker, scheduler, reports], Language: go, DB: cassandra, Cloud: azure, Latency p95: 50ms, Cost: $253/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"keyspaces\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"cassandra\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth, payments], Language: typescript, DB: mysql, Cloud: azure, Queues: sqs, Latency p95: 500ms, Cost: $156/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"sqs\", \"ecr\"], \"topology\": \"2 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"2 services with mysql fit well in ECS containers\"}, \"inputs\": {\"service_count\": 2, \"cloud_provider\": \"azure\", \"database\": \"mysql\", \"language\": \"typescript\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [auth], Language: rust, DB: dynamodb, Cloud: gcp, Latency p95: 100ms, Cost: $83/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on gcp\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Single service with dynamodb is ideal for serverless architecture\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"gcp\", \"database\": \"dynamodb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend, frontend, scheduler, notifications], Language: go, DB: postgres, Cloud: azure, Latency p95: 200ms, Cost: $166/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"microservices_ecs\", \"components\": [\"alb\", \"ecs_cluster\", \"cloudwatch\", \"elasticache\", \"rds\", \"ecr\"], \"topology\": \"4 services with microservices_ecs pattern on azure\", \"scaling_strategy\": \"horizontal_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"ECS provides good balance of control and managed infrastructure for 4 services\"}, \"inputs\": {\"service_count\": 4, \"cloud_provider\": \"azure\", \"database\": \"postgres\", \"language\": \"go\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [backend], Language: rust, DB: documentdb, Cloud: aws, Scheduled: true, Latency p95: 300ms, Cost: $67/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"serverless\", \"components\": [\"api_gateway\", \"sns\", \"s3\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\"], \"topology\": \"1 services with serverless pattern on aws\", \"scaling_strategy\": \"serverless_autoscaling\", \"estimated_cost_tier\": \"medium\", \"rationale\": \"Scheduled workloads are perfect for Lambda with EventBridge\"}, \"inputs\": {\"service_count\": 1, \"cloud_provider\": \"aws\", \"database\": \"documentdb\", \"language\": \"rust\"}, \"source\": \"ai_recommendation\"}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service profiles, recommend the optimal architecture.\n\nYou MUST respond with ONLY valid JSON in this EXACT format:\n{\n \"architecture\": {\n \"pattern\": \"serverless\" or \"microservices_ecs\" or \"kubernetes\" or \"event_driven\" or \"lift_and_shift\",\n \"components\": [\"api_gateway\", \"lambda\", \"ecs_cluster\", \"alb\", \"rds\", \"elasticache\", etc.],\n \"topology\": \"N services with PATTERN pattern on CLOUD\",\n \"scaling_strategy\": \"horizontal_autoscaling\" or \"serverless_autoscaling\" or \"kubernetes_hpa\",\n \"estimated_cost_tier\": \"low\" or \"medium\" or \"high\",\n \"rationale\": \"Brief explanation of why this architecture\"\n },\n \"inputs\": {\n \"service_count\": NUMBER,\n \"cloud_provider\": \"aws\" or \"gcp\" or \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}\n\nDo NOT include any text outside the JSON. Components must be strings, not objects."}, {"role": "user", "content": "Services: [api, consumer, processor], Language: java, DB: documentdb, Cloud: azure, Queues: kafka, Latency p95: 50ms, Cost: $422/day"}, {"role": "assistant", "content": "{\"architecture\": {\"pattern\": \"event_driven\", \"components\": [\"msk\", \"dynamodb\", \"documentdb\", \"eventbridge\", \"lambda\", \"sqs\", \"kinesis\"], \"topology\": \"3 services with event_driven pattern on azure\", \"scaling_strategy\": \"event_driven_scaling\", \"estimated_cost_tier\": \"high\", \"rationale\": \"Real-time streaming with kafka needs event-driven pattern\"}, \"inputs\": {\"service_count\": 3, \"cloud_provider\": \"azure\", \"database\": \"documentdb\", \"language\": \"java\"}, \"source\": \"ai_recommendation\"}"}]} diff --git a/oumi/oumi_synth_data.jsonl b/oumi/oumi_synth_data.jsonl new file mode 100644 index 0000000..b40ed90 --- /dev/null +++ b/oumi/oumi_synth_data.jsonl @@ -0,0 +1,50 @@ +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 5 microservices, Language: typescript, DB: redis, Cloud: azure, App type: e-commerce"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"Redis\", \"Elasticsearch\", \"Kubernetes\", \"API Gateway\", \"Frontend\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"E-commerce applications often require a high level of scalability and flexibility, making microservices-based architectures a good fit. The use of Kubernetes for orchestration and the Redis and Elasticsearch for data storage and search, respectively, provide the necessary infrastructure for this type of application. The API Gateway and Frontend components are essential for handling API requests and providing a user-friendly experience for the end-users.\"\n },\n \"inputs\": {\n \"service_count\": 5,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 6 microservices, Language: python, DB: dynamodb, Cloud: gcp, App type: fintech"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"components\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"serverless_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"Microservices architecture is ideal for Fintech applications as it allows for better scalability and easier management of services. ECS (Elastic Container Service) is a scalable container orchestration service that can be used to run microservices in a cloud environment. The serverless_autoscaling strategy ensures that the number of instances in the ECS cluster is automatically scaled based on the workload, which is ideal for Fintech applications where the number of instances can change based on demand.\"\n },\n \"inputs\": {\n \"service_count\": 6,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 5 microservices, Language: go, DB: cassandra, Cloud: gcp, App type: enterprise"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"Microservices architecture is ideal for this scenario as it allows for better scalability and flexibility, especially with the use of microservices. The use of Kubernetes for orchestration and the deployment of microservices on GCP makes it highly scalable and cost-effective. The use of event-driven architecture ensures that the system can adapt to changes in the environment.\"\n },\n \"inputs\": {\n \"service_count\": 5,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 3 microservices, Language: javascript, DB: mysql, Cloud: azure, App type: iot"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"The architecture is designed to be microservices-based, with each microservice running on a separate EC2 instance. This allows for better scalability and easier management of the services. The use of Kubernetes for orchestration ensures that the services are easily deployable and manageable. The horizontal autoscaling strategy is chosen to handle the varying load of the services, while the cost tier of medium reflects the moderate cost of running the services in a microservices architecture.\"\n },\n \"inputs\": {\n \"service_count\": 3,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 6 microservices, Language: go, DB: dynamodb, Cloud: azure, App type: fintech"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"DynamoDB\", \"Go microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"serverless_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"DynamoDB provides high performance for storing and querying data, while Go microservices are ideal for handling complex business logic and data processing. Serverless and event-driven architectures are suitable for this scenario, as they allow for efficient scaling and cost optimization. Kubernetes is chosen for the cloud provider, and the architecture is designed to be highly scalable and cost-effective.\"\n },\n \"inputs\": {\n \"service_count\": 6,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 5 microservices, Language: javascript, DB: mysql, Cloud: gcp, App type: iot"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"Microservices architecture is ideal for this scenario as it allows for better scalability and easier management of the services. It also provides better isolation and easier maintenance of the services.\"\n },\n \"inputs\": {\n \"service_count\": 5,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 6 microservices, Language: typescript, DB: postgres, Cloud: azure, App type: e-commerce"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"E-commerce applications often require a microservices architecture to scale independently and efficiently. The use of Kubernetes for orchestration and the Elastic Load Balancer (ELB) for horizontal scaling makes this a suitable choice.\"\n },\n \"inputs\": {\n \"service_count\": 6,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 4 microservices, Language: typescript, DB: dynamodb, Cloud: azure, App type: saas"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"DynamoDB\", \"Azure Functions\", \"Azure App Service\", \"Azure App Service with Load Balancer\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"serverless_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to be highly scalable and cost-effective, leveraging microservices and serverless computing for efficient and efficient resource management.\"\n },\n \"inputs\": {\n \"service_count\": 4,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 1 microservices, Language: python, DB: dynamodb, Cloud: azure, App type: mobile"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\",\n \"components\": [\"list\", \"of\", \"components\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to be highly scalable and cost-effective, leveraging serverless and microservices architectures to handle the high demand of mobile applications running on the cloud.\"\n },\n \"inputs\": {\n \"service_count\": 1,\n \"cloud_provider\": \"azure\",\n \"app_type\": \"mobile\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 2 microservices, Language: typescript, DB: postgres, Cloud: gcp, App type: enterprise"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"serverless|microservices_ecs\"],\n \"topology\": \"microservices\",\n \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"Enterprise applications often require a more flexible and scalable architecture, especially when dealing with large datasets and complex business logic. Microservices architecture is well-suited for this type of workload, as it allows for the creation of small, independent services that can be scaled independently. Additionally, Kubernetes is a popular choice for managing and scaling microservices, making it a good fit for this architecture. The use of horizontal autoscaling and Kubernetes HPA ensures that the application can handle high traffic and resource demands, while the serverless approach allows for cost optimization and cost management.\"\n },\n \"inputs\": {\n \"service_count\": 2,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 5 microservices, Language: go, DB: postgres, Cloud: aws, App type: enterprise"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"microservices\"],\n \"topology\": \"EC2-based architecture\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"This architecture is suitable for a microservices-based application with a language of Go and a database of PostgreSQL. It leverages AWS EC2 for scaling and provides horizontal autoscaling for cost optimization.\"\n },\n \"inputs\": {\n \"service_count\": 5,\n \"cloud_provider\": \"aws\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 6 microservices, Language: go, DB: dynamodb, Cloud: aws, App type: saas"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\",\n \"components\": [\"list\", \"of\", \"components\"],\n \"topology\": \"serverless\",\n \"scaling_strategy\": \"serverless_autoscaling|kubernetes_hpa\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to be highly scalable and cost-effective, leveraging AWS services for serverless computing and Kubernetes for horizontal scaling and orchestration. The use of event-driven architecture allows for efficient handling of events and data flow, while the serverless approach ensures that the services can be provisioned and managed independently of the underlying infrastructure.\"\n },\n \"inputs\": {\n \"service_count\": 6,\n \"cloud_provider\": \"aws\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 5 microservices, Language: typescript, DB: mongodb, Cloud: aws, App type: enterprise"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"serverless_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"Microservices architecture is ideal for this scenario as it allows for better scalability and easier management of the services. The use of AWS Elastic Beanstalk or Kubernetes for deployment and scaling is recommended for this environment.\"\n },\n \"inputs\": {\n \"service_count\": 5,\n \"cloud_provider\": \"aws\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 5 microservices, Language: javascript, DB: dynamodb, Cloud: gcp, App type: saas"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"components\"],\n \"topology\": \"EC2-based architecture\",\n \"scaling_strategy\": \"serverless_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"This architecture is suitable for a JavaScript-based SaaS application running on Google Cloud Platform (GCP). It leverages EC2 instances for scaling and provides a scalable and cost-effective solution for the microservices.\"\n },\n \"inputs\": {\n \"service_count\": 5,\n \"cloud_provider\": \"GCP\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 8 microservices, Language: java, DB: mongodb, Cloud: aws, App type: mobile"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"Microservices architecture is ideal for mobile applications as it allows for better scalability and flexibility, as each microservice can be independently scaled up or down based on demand.\"\n },\n \"inputs\": {\n \"service_count\": 8,\n \"cloud_provider\": \"aws\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 2 microservices, Language: javascript, DB: mysql, Cloud: gcp, App type: iot"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"serverless|microservices_ecs\"],\n \"topology\": \"microservices\",\n \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to be highly scalable and cost-effective, with a focus on microservices and microservices-based architectures. It leverages Kubernetes for horizontal scaling and event-driven architecture for better fault tolerance and scalability.\"\n },\n \"inputs\": {\n \"service_count\": 2,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 3 microservices, Language: go, DB: mongodb, Cloud: gcp, App type: e-commerce"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"Go microservices\", \"MongoDB database\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"The architecture is designed to scale horizontally using Kubernetes, which is a popular open-source container orchestration platform. The microservices are designed to be loosely coupled and loosely scaled, making it easy to add or remove services as needed. The use of MongoDB as the database ensures data consistency and security, while Kubernetes provides a scalable and automated way to manage the services. The combination of microservices and a database makes this architecture highly scalable and cost-effective.\"\n },\n \"inputs\": {\n \"service_count\": 3,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 8 microservices, Language: python, DB: mysql, Cloud: azure, App type: startup"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"serverless_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"Microservices architecture is ideal for Python applications running on Azure, as it allows for better scalability and easier management of services. The use of Kubernetes for orchestration and horizontal scaling is also recommended for this architecture.\"\n },\n \"inputs\": {\n \"service_count\": 8,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 5 microservices, Language: python, DB: redis, Cloud: gcp, App type: e-commerce"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"E-commerce applications often benefit from microservices architecture, which allows for better scalability and easier maintenance. The use of Kubernetes for orchestration and the Redis database for caching and message queueing makes this architecture highly scalable and cost-effective.\"\n },\n \"inputs\": {\n \"service_count\": 5,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 1 microservices, Language: go, DB: mongodb, Cloud: gcp, App type: saas"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"serverless|microservices_ecs\"],\n \"topology\": \"microservices\",\n \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to be highly scalable and cost-effective, leveraging microservices for better flexibility and easier maintenance. The use of Kubernetes for orchestration allows for easy scaling and management of the application. The use of event-driven architecture ensures that the application can respond quickly to changes in the environment.\"\n },\n \"inputs\": {\n \"service_count\": 1,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 5 microservices, Language: java, DB: postgres, Cloud: gcp, App type: enterprise"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"Java microservices\", \"PostgreSQL database\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to scale horizontally using Kubernetes, which is a popular open-source container orchestration platform. The microservices are designed to be loosely coupled and can be scaled independently, making it suitable for an enterprise environment.\"\n },\n \"inputs\": {\n \"service_count\": 5,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 2 microservices, Language: java, DB: cassandra, Cloud: gcp, App type: mobile"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"Java microservices\", \"Cassandra database\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"The architecture is designed to be highly scalable and horizontally scalable, with a focus on microservices for better maintainability and flexibility. The use of Cassandra as the database ensures high availability and performance, while the Java microservices provide a robust and scalable foundation for mobile applications.\"\n },\n \"inputs\": {\n \"service_count\": 2,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 6 microservices, Language: go, DB: postgres, Cloud: azure, App type: enterprise"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"serverless_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"Microservices architecture is ideal for this scenario as it allows for better scalability and easier management of the application. The use of Kubernetes for orchestration and the deployment of microservices makes it highly scalable and cost-effective. The use of event-driven architecture ensures that the application can respond quickly to changes in the environment.\"\n },\n \"inputs\": {\n \"service_count\": 6,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 6 microservices, Language: typescript, DB: dynamodb, Cloud: aws, App type: iot"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"serverless|microservices_ecs\"],\n \"topology\": \"ec2|dynamodb|aws|iot\",\n \"scaling_strategy\": \"serverless_autoscaling|kubernetes_hpa\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to be highly scalable and cost-effective, leveraging AWS EC2, DynamoDB, and AWS IoT for the microservices. The serverless approach allows for easy scaling and management, while the Kubernetes HPA ensures high availability and performance.\"\n },\n \"inputs\": {\n \"service_count\": 6,\n \"cloud_provider\": \"aws\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 1 microservices, Language: typescript, DB: dynamodb, Cloud: gcp, App type: e-commerce"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\",\n \"components\": [\"list\", \"of\", \"components\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The e-commerce service uses TypeScript for the backend logic, which is suitable for a microservices architecture. The use of DynamoDB for the database is also a good choice as it provides high availability and scalability. Kubernetes is a popular choice for microservices, and event-driven architectures are ideal for e-commerce applications. The use of serverless services is also a good choice as it can help in reducing costs and improving scalability. The estimated cost tier is high as the services are highly scalable and cost-effective.\"\n },\n \"inputs\": {\n \"service_count\": 1,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 6 microservices, Language: go, DB: cassandra, Cloud: azure, App type: mobile"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"Microservices architecture is ideal for handling the complexity of 6 microservices, each with its own database and language. The use of microservices allows for easier scaling and management of the services, as each microservice can be independently scaled up or down based on demand. Additionally, the use of Kubernetes for orchestration and management of the microservices ensures that the services are easily deployable and maintainable. The use of event-driven architecture allows for real-time updates and responses, which is crucial for mobile applications. The use of cloud providers like Azure for the cloud environment ensures that the services can be easily deployed and managed, and the cost is relatively low compared to traditional on-premises solutions.\"\n },\n \"inputs\": {\n \"service_count\": 6,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 8 microservices, Language: python, DB: cassandra, Cloud: aws, App type: saas"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"microservices\"],\n \"topology\": \"ec2\",\n \"scaling_strategy\": \"serverless_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"ECS (Elastic Container Service) is a scalable container orchestration service that can be used to run microservices in a cloud environment. It provides automatic scaling based on demand, making it ideal for running multiple microservices in a single cloud environment.\"\n },\n \"inputs\": {\n \"service_count\": 8,\n \"cloud_provider\": \"aws\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 6 microservices, Language: python, DB: postgres, Cloud: aws, App type: fintech"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"microservices\"],\n \"topology\": \"ec2\",\n \"scaling_strategy\": \"serverless_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"ECS (Elastic Container Service) is a scalable container orchestration service that can be used to run microservices in a cloud environment. It provides automatic scaling based on demand, making it ideal for running Python microservices on AWS. The'serverless_autoscaling' strategy ensures that the cost of running the services is kept low, as it scales automatically based on the number of instances running. This approach is suitable for a fintech application that requires high availability and low cost.\"\n },\n \"inputs\": {\n \"service_count\": 6,\n \"cloud_provider\": \"aws\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 2 microservices, Language: python, DB: cassandra, Cloud: azure, App type: saas"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"serverless|microservices_ecs\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to be highly scalable and cost-effective, leveraging microservices and Kubernetes for horizontal scaling and auto-scaling, respectively. The use of Cassandra as the database ensures data integrity and availability, and the use of Python as the programming language allows for easy integration with the microservices.\"\n },\n \"inputs\": {\n \"service_count\": 2,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 2 microservices, Language: python, DB: postgres, Cloud: aws, App type: e-commerce"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\",\n \"components\": [\"list\", \"of\", \"components\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to be highly scalable and cost-effective, leveraging AWS services for microservices and Kubernetes for orchestration. The use of event-driven architecture ensures that the system can adapt to changes in the environment, and the microservices are designed to be loosely coupled, making it easier to scale and maintain. The use of serverless architecture allows for efficient resource management and cost optimization.\"\n },\n \"inputs\": {\n \"service_count\": 2,\n \"cloud_provider\": \"aws\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 5 microservices, Language: python, DB: mongodb, Cloud: azure, App type: e-commerce"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"E-commerce applications often require a high level of scalability and flexibility, making microservices an ideal choice. By using ECS (Elastic Container Service) for microservices, we can ensure that each microservice can be scaled independently, which is crucial for maintaining high availability and performance in a high-traffic environment.\"\n },\n \"inputs\": {\n \"service_count\": 5,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 6 microservices, Language: java, DB: dynamodb, Cloud: aws, App type: fintech"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"Java microservices\", \"DynamoDB database\", \"AWS cloud provider\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to be highly scalable and horizontally scalable, leveraging AWS's Elastic Load Balancing (ELB) and Auto Scaling for cost optimization. The Java microservices are designed to be loosely coupled and loosely scaled, while the DynamoDB database provides a scalable and durable storage solution. The AWS cloud provider offers a high level of security and reliability, making it suitable for a fintech application.\"\n },\n \"inputs\": {\n \"service_count\": 6,\n \"cloud_provider\": \"aws\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 8 microservices, Language: python, DB: mysql, Cloud: azure, App type: mobile"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"Microservices architecture is ideal for Python mobile applications as it allows for better scalability and flexibility. It separates concerns and makes it easier to manage and scale individual services independently.\"\n },\n \"inputs\": {\n \"service_count\": 8,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 6 microservices, Language: java, DB: cassandra, Cloud: azure, App type: iot"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"Java microservices\", \"Cassandra database\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"The architecture is designed to be microservices-based, with each microservice running on a separate EC2 instance. The Cassandra database is used for storing and querying data, and it is designed to be horizontally scaled to handle increased load. The estimated cost tier is medium, as it balances between cost and performance.\"\n },\n \"inputs\": {\n \"service_count\": 6,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 2 microservices, Language: go, DB: redis, Cloud: gcp, App type: mobile"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"The architecture is designed to be highly scalable and horizontally scalable, with a focus on microservices to ensure flexibility and agility in the application's architecture.\"\n },\n \"inputs\": {\n \"service_count\": 2,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 8 microservices, Language: python, DB: redis, Cloud: azure, App type: saas"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"Microservices architecture is ideal for Python applications with Redis as a database. It allows for easy scaling and isolation of services, which is crucial for a scalable and maintainable application.\"\n },\n \"inputs\": {\n \"service_count\": 8,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 8 microservices, Language: typescript, DB: cassandra, Cloud: azure, App type: saas"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"serverless|microservices_ecs\"],\n \"topology\": \"ec2\",\n \"scaling_strategy\": \"serverless_autoscaling|kubernetes_hpa\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to be highly scalable and cost-effective, leveraging AWS EC2 for the underlying infrastructure and Kubernetes for the application. The use of serverless services allows for efficient management of the application's runtime, while the use of Kubernetes provides a scalable and managed environment for the application.\"\n },\n \"inputs\": {\n \"service_count\": 8,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 8 microservices, Language: go, DB: dynamodb, Cloud: azure, App type: e-commerce"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"DynamoDB\", \"Elasticsearch\", \"Kubernetes\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"serverless_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"Elasticity and scalability are key requirements for an e-commerce application. The microservices architecture allows for the creation of highly scalable and flexible components, while the use of Kubernetes provides a scalable and managed environment for running these services. The use of DynamoDB and Elasticsearch ensures data storage and retrieval, while Kubernetes provides a scalable and managed environment for running these services. The combination of these components allows for the efficient and cost-effective deployment of an e-commerce application.\"\n },\n \"inputs\": {\n \"service_count\": 8,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 1 microservices, Language: java, DB: redis, Cloud: aws, App type: enterprise"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"Java microservices\", \"Redis database\", \"AWS cloud\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to be highly scalable and horizontally scalable, leveraging AWS's elasticity and auto-scaling capabilities to handle the high demand of the enterprise service. The microservices architecture allows for easy maintenance and management of the application, while the Redis database provides fast and reliable data storage for the enterprise.\"\n },\n \"inputs\": {\n \"service_count\": 1,\n \"cloud_provider\": \"aws\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 6 microservices, Language: typescript, DB: redis, Cloud: gcp, App type: startup"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"Microservices architecture is ideal for TypeScript applications running on GCP, as it allows for better scalability and easier management of services. The use of Kubernetes for orchestration and horizontal scaling makes it highly scalable and cost-effective.\"\n },\n \"inputs\": {\n \"service_count\": 6,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 5 microservices, Language: java, DB: postgres, Cloud: gcp, App type: enterprise"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"Java microservices\", \"PostgreSQL database\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to scale horizontally using Kubernetes, which is a popular open-source container orchestration platform. The microservices are designed to be loosely coupled and can be scaled independently, making it suitable for an enterprise environment.\"\n },\n \"inputs\": {\n \"service_count\": 5,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 2 microservices, Language: java, DB: cassandra, Cloud: azure, App type: enterprise"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"Java microservices\", \"Cassandra database\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"The architecture is designed to be highly scalable and horizontally scalable, with a focus on microservices and Cassandra for data storage. This approach ensures that the system can handle increased load and maintain optimal performance.\"\n },\n \"inputs\": {\n \"service_count\": 2,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 3 microservices, Language: typescript, DB: dynamodb, Cloud: gcp, App type: iot"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"serverless|microservices_ecs\"],\n \"topology\": \"microservices\",\n \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to be highly scalable and horizontally scalable, with a focus on microservices. It leverages AWS Lambda for serverless functions, DynamoDB for database, and GCP for cloud services. The use of Kubernetes for orchestration allows for easy management of the microservices and the cloud environment. The high cost tier is chosen to ensure cost efficiency.\"\n },\n \"inputs\": {\n \"service_count\": 3,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 1 microservices, Language: javascript, DB: redis, Cloud: gcp, App type: iot"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"The architecture is designed to be highly scalable and horizontally scalable, suitable for a microservices architecture with a JavaScript language and Redis database. The use of ECS (Elastic Container Service) ensures that the services can be easily scaled horizontally, and the use of Kubernetes for the application ensures that the architecture is also highly available and fault-tolerant.\"\n },\n \"inputs\": {\n \"service_count\": 1,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 4 microservices, Language: go, DB: postgres, Cloud: azure, App type: enterprise"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"Microservices architecture is ideal for this scenario as it allows for better scalability and easier management of the application. The use of Kubernetes for orchestration and the deployment of microservices makes it highly scalable and cost-effective. The use of Event-Driven Architecture ensures that the application can be easily deployed and scaled in response to changes in demand.\"\n },\n \"inputs\": {\n \"service_count\": 4,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 1 microservices, Language: python, DB: mongodb, Cloud: gcp, App type: saas"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"components\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"The architecture is designed to be highly scalable and horizontally scalable, leveraging Kubernetes for orchestration and microservices for better maintainability and flexibility.\"\n },\n \"inputs\": {\n \"service_count\": 1,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 5 microservices, Language: java, DB: mysql, Cloud: gcp, App type: startup"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"Microservices architecture is ideal for this scenario as it allows for easy scaling and isolation of services, which is crucial for a startup environment.\"\n },\n \"inputs\": {\n \"service_count\": 5,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 8 microservices, Language: java, DB: postgres, Cloud: azure, App type: mobile"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"Microservices architecture is ideal for handling the complexity of 8 microservices, each with its own database and language. It allows for easy scaling and isolation of services, which is crucial for mobile applications. Kubernetes is also a good choice for this architecture as it provides a scalable and managed environment for deploying and managing microservices. The use of event-driven architecture is also recommended for handling real-time data and updates.\"\n },\n \"inputs\": {\n \"service_count\": 8,\n \"cloud_provider\": \"azure\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 8 microservices, Language: go, DB: cassandra, Cloud: gcp, App type: saas"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"horizontal_autoscaling\",\n \"estimated_cost_tier\": \"medium\",\n \"rationale\": \"Microservices architecture is ideal for this scenario as it allows for easy scaling and isolation of services, which is crucial for a cloud-based application like a SaaS service.\"\n },\n \"inputs\": {\n \"service_count\": 8,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} +{"messages": [{"role": "system", "content": "You are an expert cloud architect. Given service specifications, recommend optimal architecture.\nRespond ONLY with valid JSON in this format:\n{\"architecture\": {\"pattern\": \"serverless|microservices_ecs|kubernetes|event_driven\", \"components\": [\"list\", \"of\", \"components\"], \"topology\": \"description\", \"scaling_strategy\": \"horizontal_autoscaling|serverless_autoscaling|kubernetes_hpa\", \"estimated_cost_tier\": \"low|medium|high\", \"rationale\": \"explanation\"}, \"inputs\": {\"service_count\": N, \"cloud_provider\": \"provider\"}, \"source\": \"ai_recommendation\"}"}, {"role": "user", "content": "Services: 8 microservices, Language: python, DB: mysql, Cloud: gcp, App type: enterprise"}, {"role": "assistant", "content": "{\n \"architecture\": {\n \"pattern\": \"microservices_ecs\",\n \"components\": [\"list\", \"of\", \"microservices\"],\n \"topology\": \"microservices_ecs\",\n \"scaling_strategy\": \"serverless_autoscaling\",\n \"estimated_cost_tier\": \"high\",\n \"rationale\": \"Microservices architecture is ideal for Python applications with a single database (MySQL) and enterprise app type. It allows for horizontal scaling and cost optimization through serverless and auto-scaling capabilities.\"\n },\n \"inputs\": {\n \"service_count\": 8,\n \"cloud_provider\": \"gcp\"\n },\n \"source\": \"ai_recommendation\"\n}"}]} diff --git a/oumi/run_inference.py b/oumi/run_inference.py new file mode 100644 index 0000000..bb7bacf --- /dev/null +++ b/oumi/run_inference.py @@ -0,0 +1,85 @@ +""" +Simple inference script for the trained Oumi model. +Uses the EXACT same prompt format as training for proper output. +""" + +from oumi import infer +from oumi.core.configs import InferenceConfig +from oumi.core.configs.params.model_params import ModelParams +from oumi.core.configs.params.generation_params import GenerationParams + +# Exact same system prompt used in training +SYSTEM_PROMPT = '''You are an expert cloud architect. Given service profiles, recommend the optimal architecture. + +You MUST respond with ONLY valid JSON in this EXACT format: +{ + "architecture": { + "pattern": "serverless" or "microservices_ecs" or "kubernetes" or "event_driven" or "lift_and_shift", + "components": ["api_gateway", "lambda", "ecs_cluster", "alb", "rds", "elasticache", etc.], + "topology": "N services with PATTERN pattern on CLOUD", + "scaling_strategy": "horizontal_autoscaling" or "serverless_autoscaling" or "kubernetes_hpa", + "estimated_cost_tier": "low" or "medium" or "high", + "rationale": "Brief explanation of why this architecture" + }, + "inputs": { + "service_count": NUMBER, + "cloud_provider": "aws" or "gcp" or "azure" + }, + "source": "ai_recommendation" +} + +Do NOT include any text outside the JSON. Components must be strings, not objects.''' + +# Create config with proper dataclass objects +config = InferenceConfig( + model=ModelParams( + model_name="Qwen/Qwen2.5-1.5B-Instruct", + adapter_model="./trained_model", + trust_remote_code=True, + ), + generation=GenerationParams( + max_new_tokens=400, + temperature=0.1, # Very low for deterministic JSON + ), +) + +# Test prompts in the exact format used for training +test_inputs = [ + "Services: [api, auth, users], Language: python, DB: postgres, Cloud: aws, Latency p95: 200ms, Cost: $100/day", + "Services: [api], Language: javascript, DB: dynamodb, Cloud: aws, Latency p95: 50ms, Cost: $20/day", + "Services: [web, api, worker, scheduler, notifications, payments], Language: go, DB: postgres, Cloud: aws, Latency p95: 300ms, Cost: $500/day", +] + +print("=" * 60) +print("InFoundry Architect - Model Inference") +print("=" * 60) + +for user_input in test_inputs: + print(f"\nInput: {user_input}\n") + + # Create a properly formatted prompt (system + user in one string) + prompt = f"{SYSTEM_PROMPT}\n\nUser Input: {user_input}\n\nJSON Response:" + + response = infer(config, [prompt]) + + # Extract the response content + result = str(response[0]) + + # Clean up any metadata artifacts + if "] metadata=" in result: + result = result.split("] metadata=")[0] + if result.startswith("["): + result = result[1:] + + # Clean up markdown code blocks if present + result = result.strip() + if result.startswith("```json"): + result = result[7:] + if result.startswith("```"): + result = result[3:] + if result.endswith("```"): + result = result[:-3] + result = result.strip() + + print(f"Response: {result}") + print("-" * 60) diff --git a/oumi/serve.py b/oumi/serve.py new file mode 100644 index 0000000..32f1cd1 --- /dev/null +++ b/oumi/serve.py @@ -0,0 +1,284 @@ +""" +Oumi Model Server for InFoundry + +Can use either: +1. Ollama (if running) +2. Local trained model +3. Heuristic fallback +""" + +import json +import os +import urllib.request +from typing import Optional + +from fastapi import FastAPI, HTTPException +from pydantic import BaseModel + +app = FastAPI(title="InFoundry Architecture Brain") + + +class Message(BaseModel): + role: str + content: str + + +class CompletionRequest(BaseModel): + model: str = "codellama" + messages: Optional[list[Message]] = None + prompt: Optional[str] = None + max_tokens: int = 2000 + temperature: float = 0.7 + + +# Configuration +OLLAMA_URL = os.environ.get("OLLAMA_URL", "http://localhost:11434") +USE_OLLAMA = os.environ.get("USE_OLLAMA", "false").lower() == "true" +USE_OUMI = os.environ.get("USE_OUMI", "true").lower() == "true" +OUMI_MODEL = "Qwen/Qwen2.5-1.5B-Instruct" +OUMI_ADAPTER = "./trained_model" + +# Lazy-loaded Oumi model +_oumi_config = None + +def get_oumi_config(): + """Get or create Oumi inference config (lazy load).""" + global _oumi_config + if _oumi_config is None: + try: + from oumi import infer + from oumi.core.configs import InferenceConfig + from oumi.core.configs.params.model_params import ModelParams + from oumi.core.configs.params.generation_params import GenerationParams + + _oumi_config = InferenceConfig( + model=ModelParams( + model_name=OUMI_MODEL, + adapter_model=OUMI_ADAPTER if os.path.exists(OUMI_ADAPTER) else None, + trust_remote_code=True, + ), + generation=GenerationParams( + max_new_tokens=400, + temperature=0.1, + ), + ) + print(f"βœ“ Loaded Oumi model: {OUMI_MODEL}") + except Exception as e: + print(f"Failed to load Oumi: {e}") + _oumi_config = False + return _oumi_config + + +def call_oumi(prompt: str) -> Optional[str]: + """Call the trained Oumi model for inference.""" + config = get_oumi_config() + if not config: + return None + try: + from oumi import infer + response = infer(config, [prompt]) + result = str(response[0]) + if "ASSISTANT:" in result: + result = result.split("ASSISTANT:")[-1].strip() + if "] metadata=" in result: + result = result.split("] metadata=")[0] + return result + except Exception as e: + print(f"Oumi error: {e}") + return None + + +def call_ollama(prompt: str, model: str = "codellama") -> Optional[str]: + """ + Request a text completion from the configured Ollama server. + + Parameters: + prompt (str): The prompt to send to Ollama. + model (str): The Ollama model name to use (defaults to "codellama"). + + Returns: + response (str) if Ollama returned a response, `None` if the request failed or no response was available. + """ + try: + payload = { + "model": model, + "prompt": prompt, + "stream": False + } + req = urllib.request.Request( + f"{OLLAMA_URL}/api/generate", + data=json.dumps(payload).encode(), + headers={"Content-Type": "application/json"} + ) + with urllib.request.urlopen(req, timeout=120) as resp: + result = json.load(resp) + return result.get("response", "") + except Exception as e: + print(f"Ollama error: {e}") + return None + + +def heuristic_response(prompt: str) -> dict: + """ + Generate a heuristic architecture recommendation based on a text prompt. + + Parameters: + prompt (str): Natural-language description of application requirements or constraints used to infer an architecture pattern. + + Returns: + dict: A dictionary with the following keys: + - pattern (str): The selected deployment pattern name (e.g., "event_driven", "kubernetes", "serverless", "microservices_ecs"). + - components (list[str]): A unique list of suggested infrastructure components. + - rationale (str): A short explanation of why the pattern was selected. + """ + prompt_lower = prompt.lower() + + # Simple pattern matching + if "kafka" in prompt_lower or "queue" in prompt_lower: + pattern = "event_driven" + components = ["msk", "lambda_functions", "eventbridge"] + elif "kubernetes" in prompt_lower or "5" in prompt or "6" in prompt: + pattern = "kubernetes" + components = ["eks_cluster", "alb", "rds", "elasticache"] + elif "lambda" in prompt_lower or "serverless" in prompt_lower: + pattern = "serverless" + components = ["api_gateway", "lambda_functions", "dynamodb"] + else: + pattern = "microservices_ecs" + components = ["ecs_cluster", "alb", "rds"] + + if "high" in prompt_lower or "latency" in prompt_lower: + components.extend(["elasticache", "cdn", "hpa"]) + + return { + "pattern": pattern, + "components": list(set(components)), + "rationale": f"Selected {pattern} based on input analysis" + } + + +@app.post("/v1/chat/completions") +async def chat_completions(request: CompletionRequest): + """ + Serve an OpenAI-compatible chat completions endpoint that produces a JSON architectural recommendation. + + Extracts the prompt from the last message in `request.messages` or from `request.prompt`; if neither is provided, raises an HTTPException with status 400. Prepends a system instruction requiring a JSON object with keys `pattern`, `components`, and `rationale`. Attempts to obtain a model-generated response via Ollama when enabled; if that fails or returns no result, falls back to a heuristic response. Returns the result wrapped in an OpenAI-like response object. + + Parameters: + request (CompletionRequest): Input payload containing either `messages` (uses the last message's content), or `prompt`; may include `model` to select the model used when calling Ollama. + + Returns: + dict: OpenAI-style response with an `"id"` of `"cmpl-infoundry"` and a single choice whose `message` (role `"assistant"`) `content` is the JSON recommendation and whose `finish_reason` is `"stop"`. + + Raises: + HTTPException: Raised with status 400 when no prompt is provided in the request. + """ + if request.messages: + prompt = request.messages[-1].content + elif request.prompt: + prompt = request.prompt + else: + raise HTTPException(400, "No prompt provided") + + # Add system prompt for architecture + full_prompt = f"""You are an expert cloud architect. Given the input, respond with ONLY a JSON object containing: +- pattern: serverless, microservices_ecs, kubernetes, or event_driven +- components: list of AWS components +- rationale: brief explanation + +Input: {prompt} + +JSON Response:""" + + response = None + + # Try Oumi first (trained model) + if USE_OUMI: + response = call_oumi(full_prompt) + + # Fall back to Ollama + if not response and USE_OLLAMA: + response = call_ollama(full_prompt, request.model) + + # Ultimate fallback to heuristics + if not response: + response = json.dumps(heuristic_response(prompt)) + + return { + "id": "cmpl-infoundry", + "choices": [{ + "message": {"role": "assistant", "content": response}, + "finish_reason": "stop" + }] + } + + +@app.post("/v1/completions") +async def completions(request: CompletionRequest): + """ + Handle legacy completions requests and produce a single text choice. + + Uses the configured Ollama service to generate text for the provided prompt; if Ollama is disabled or returns no result, falls back to a heuristic-derived response. + + Parameters: + request (CompletionRequest): Request object containing at least `prompt` (string) and optional `model`. + + Returns: + dict: A response object with a `choices` list containing a single item with keys: + - `text`: the generated response string (JSON-serialized when from the heuristic fallback) + - `finish_reason`: the string "stop" + """ + prompt = request.prompt or "" + + response = None + + # Try Oumi first + if USE_OUMI: + response = call_oumi(prompt) + + # Fall back to Ollama + if not response and USE_OLLAMA: + response = call_ollama(prompt, request.model) + + # Ultimate fallback + if not response: + response = json.dumps(heuristic_response(prompt)) + + return { + "choices": [{"text": response, "finish_reason": "stop"}] + } + + +@app.get("/health") +async def health(): + # Check if Ollama is available + """ + Return overall service health and whether the configured Ollama service is reachable. + + Performs a quick availability probe of the configured Ollama URL and reports the result. + + Returns: + dict: A mapping with keys: + - "status": the service health string ("healthy"). + - "ollama_available": `True` if Ollama responded to the probe, `False` otherwise. + - "ollama_url": the configured Ollama base URL. + """ + ollama_ok = False + try: + req = urllib.request.Request(f"{OLLAMA_URL}/api/tags") + with urllib.request.urlopen(req, timeout=5) as resp: + ollama_ok = resp.status == 200 + except: + pass + + return { + "status": "healthy", + "ollama_available": ollama_ok, + "ollama_url": OLLAMA_URL + } + + +if __name__ == "__main__": + import uvicorn + print(f"Starting server... Ollama URL: {OLLAMA_URL}") + uvicorn.run(app, host="0.0.0.0", port=8000) \ No newline at end of file diff --git a/oumi/train_sft.py b/oumi/train_sft.py new file mode 100644 index 0000000..e44f4c2 --- /dev/null +++ b/oumi/train_sft.py @@ -0,0 +1,96 @@ +""" +Oumi SFT Training Script for InFoundry Architect +Trains on generated_training_data.jsonl with proper architecture plan format. +""" + +from pathlib import Path + +from oumi import train +from oumi.core.configs import TrainingConfig +from oumi.core.configs.params.model_params import ModelParams +from oumi.core.configs.params.training_params import TrainingParams, TrainerType +from oumi.core.configs.params.data_params import DataParams, DatasetParams, DatasetSplitParams +from oumi.core.configs.params.peft_params import PeftParams + + +def run_training(): + """ + Run SFT training on architecture recommendation data using Oumi. + + Checks for the presence of generated_training_data.jsonl, builds a TrainingConfig with model, training, data, and LoRA (PEFT) settings, and runs training when the data file exists. If the data file is missing the function prints an error and returns without running training. + + Returns: + The object returned by train(config) when training runs, or `None` if training did not start because the data file was missing. + """ + + # Check that training data exists + data_file = Path("generated_training_data.jsonl") + if not data_file.exists(): + print("❌ Training data not found. Run: python generate_training_data.py --count 500") + return + + # Count examples + with open(data_file) as f: + num_examples = sum(1 for _ in f) + print(f"πŸ“Š Training on {num_examples} examples from {data_file}") + + # Configure training - use 0.5B model but train longer for better results + config = TrainingConfig( + model=ModelParams( + # Using 1.5B model (trained on Colab T4) + model_name="Qwen/Qwen2.5-1.5B-Instruct", + trust_remote_code=True, + ), + training=TrainingParams( + trainer_type=TrainerType.TRL_SFT, + output_dir="./trained_model", + num_train_epochs=5, # More epochs for better learning + per_device_train_batch_size=1, # Small batch to save memory + gradient_accumulation_steps=8, # Effective batch size = 8 + learning_rate=5e-6, # Lower LR for fine-grained learning + max_steps=500, # Many more steps + save_steps=100, + logging_steps=25, + use_peft=True, + warmup_ratio=0.1, + ), + data=DataParams( + train=DatasetSplitParams( + datasets=[ + DatasetParams( + dataset_name="text_sft", + dataset_path=str(data_file.absolute()), + ) + ] + ) + ), + peft=PeftParams( + lora_r=64, # Higher rank for better capacity + lora_alpha=128, + lora_dropout=0.05, + ), + ) + + print("=" * 60) + print(" InFoundry Architect - Oumi SFT Training") + print(" Training on architecture recommendation data") + print("=" * 60) + print(f" Model: {config.model.model_name}") + print(f" Training Type: SFT with LoRA") + print(f" Data: {data_file} ({num_examples} examples)") + print(f" Max Steps: {config.training.max_steps}") + print(f" LoRA rank: {config.peft.lora_r}") + print(f" Output: {config.training.output_dir}") + print("=" * 60) + + # Run training + result = train(config) + + print("\nβœ“ Training complete!") + print(f" Model saved to: {config.training.output_dir}") + + return result + + +if __name__ == "__main__": + run_training() diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..4cae1e8 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,13 @@ +# InFoundry Python Dependencies + +# Core +fastapi>=0.100.0 +uvicorn>=0.23.0 +pydantic>=2.0.0 + +# Testing +pytest>=7.0.0 +httpx>=0.24.0 + +# Oumi (optional - for model training/serving) +# oumi[gpu] # Uncomment if training locally diff --git a/scripts/compute_reward.py b/scripts/compute_reward.py deleted file mode 100644 index de208af..0000000 --- a/scripts/compute_reward.py +++ /dev/null @@ -1,12 +0,0 @@ -def reward(before: dict, after: dict, weights=(0.4, 0.5, 0.1)) -> float: - cost_delta = (before.get("cost", 0) - after.get("cost", 0)) / max(1, before.get("cost", 1)) - latency_delta = (before.get("p95", 0) - after.get("p95", 0)) / max(1, before.get("p95", 1)) - reliability_delta = after.get("uptime", 1.0) - before.get("uptime", 1.0) - return weights[0] * cost_delta + weights[1] * latency_delta + weights[2] * reliability_delta - - -if __name__ == "__main__": - before_state = {"cost": 60, "p95": 420, "uptime": 0.99} - after_state = {"cost": 50, "p95": 310, "uptime": 0.995} - print(f"reward={reward(before_state, after_state):.4f}") - diff --git a/scripts/generate-pr.sh b/scripts/generate-pr.sh new file mode 100755 index 0000000..697026d --- /dev/null +++ b/scripts/generate-pr.sh @@ -0,0 +1,96 @@ +#!/bin/bash +# Generate a PR message using Cline CLI +# Usage: ./generate-pr.sh [base-branch] [output-file] +# Example: ./generate-pr.sh dev PR_DESCRIPTION.md + +set -euo pipefail + +BASE_BRANCH="${1:-dev}" +OUTPUT_FILE="${2:-}" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)" + +# Get the current branch name +CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD) + +# Find the merge base (where the branch diverged from base) +MERGE_BASE=$(git merge-base "$BASE_BRANCH" HEAD 2>/dev/null || echo "") + +if [ -z "$MERGE_BASE" ]; then + echo "Error: Could not find common ancestor between $CURRENT_BRANCH and $BASE_BRANCH" >&2 + exit 1 +fi + +# Get changes since branching from base +DIFF_STAT=$(git diff --stat "$MERGE_BASE"..HEAD) +FILES_CHANGED=$(git diff --name-only "$MERGE_BASE"..HEAD) +COMMIT_MESSAGES=$(git log --oneline "$MERGE_BASE"..HEAD) +COMMIT_COUNT=$(git rev-list --count "$MERGE_BASE"..HEAD) + +echo "# Analyzing $COMMIT_COUNT commits since branching from $BASE_BRANCH..." >&2 + +# Read the PR template +TEMPLATE=$(cat "$REPO_ROOT/.github/PULL_REQUEST_TEMPLATE.md" 2>/dev/null || echo "") + +# Write context to a temp file for Cline to read +CONTEXT_FILE=$(mktemp) +cat > "$CONTEXT_FILE" << EOF +Generate a GitHub Pull Request description for the following changes. + +## SOURCE BRANCH: $CURRENT_BRANCH +## TARGET BRANCH: $BASE_BRANCH +## NUMBER OF COMMITS: $COMMIT_COUNT + +## COMMIT MESSAGES: +$COMMIT_MESSAGES + +## FILES CHANGED: +$FILES_CHANGED + +## DIFF STATISTICS: +$DIFF_STAT + +## PR TEMPLATE TO FOLLOW: +$TEMPLATE + +INSTRUCTIONS: +1. Follow the PR template structure exactly +2. Check appropriate checkboxes with [x] based on what changed +3. Fill in the Description based on the commits +4. List the Changes Made from the commit messages +5. Output ONLY the completed markdown, nothing else +EOF + +echo "# Running Cline CLI..." >&2 + +# Run Cline with the context file +cline -y "Read $CONTEXT_FILE and generate a PR description following the template. Output only markdown." --mode act 2>/dev/null || { + echo "# Cline failed, falling back to basic template..." >&2 + cat << ENDPR +# Pull Request + +## Description +Branch \`$CURRENT_BRANCH\` β†’ \`$BASE_BRANCH\` ($COMMIT_COUNT commits) + +## Type of Change +- [x] ✨ New feature (non-breaking change that adds functionality) + +## Changes Made +$(echo "$COMMIT_MESSAGES" | sed 's/^[a-f0-9]* /- /') + +## Files Changed +\`\`\` +$DIFF_STAT +\`\`\` + +## Checklist +- [x] My code follows the project's coding standards +- [x] I have performed a self-review of my code + +--- +*Generated by InFoundry* +ENDPR +} + +# Cleanup +rm -f "$CONTEXT_FILE" diff --git a/scripts/simulate_load.py b/scripts/simulate_load.py deleted file mode 100644 index e3a0f23..0000000 --- a/scripts/simulate_load.py +++ /dev/null @@ -1,23 +0,0 @@ -""" -Minimal synthetic load script placeholder. -Extend with k6/vegeta integration or requests-based probes. -""" -import time -import random - - -def simulate(service: str, duration_seconds: int = 5) -> dict: - latencies = [random.randint(80, 250) for _ in range(50)] - errors = [0 if random.random() > 0.95 else 1 for _ in range(50)] - time.sleep(duration_seconds / 10) - return { - "service": service, - "p50": sorted(latencies)[25], - "p95": sorted(latencies)[47], - "error_rate": sum(errors) / len(errors), - } - - -if __name__ == "__main__": - print(simulate("auth")) - diff --git a/services/auth/Dockerfile b/services/auth/Dockerfile deleted file mode 100644 index 7a6fd12..0000000 --- a/services/auth/Dockerfile +++ /dev/null @@ -1,7 +0,0 @@ -FROM python:3.11-slim -WORKDIR /app -COPY app.py /app/app.py -RUN pip install fastapi uvicorn -EXPOSE 8000 -CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"] - diff --git a/services/auth/app.py b/services/auth/app.py deleted file mode 100644 index 64835a2..0000000 --- a/services/auth/app.py +++ /dev/null @@ -1,15 +0,0 @@ -from fastapi import FastAPI - -app = FastAPI() - - -@app.get("/healthz") -async def health(): - return {"status": "ok"} - - -@app.get("/hello") -async def hello(): - return {"service": "auth", "message": "hello from auth"} - - diff --git a/services/payments/Dockerfile b/services/payments/Dockerfile deleted file mode 100644 index 9fd4e50..0000000 --- a/services/payments/Dockerfile +++ /dev/null @@ -1,7 +0,0 @@ -FROM python:3.11-slim -WORKDIR /app -COPY app.py /app/app.py -RUN pip install fastapi uvicorn -EXPOSE 8001 -CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8001"] - diff --git a/services/payments/app.py b/services/payments/app.py deleted file mode 100644 index 86a13cf..0000000 --- a/services/payments/app.py +++ /dev/null @@ -1,15 +0,0 @@ -from fastapi import FastAPI - -app = FastAPI() - - -@app.get("/healthz") -async def health(): - return {"status": "ok"} - - -@app.get("/charge") -async def charge(): - return {"service": "payments", "message": "mock charge processed"} - - diff --git a/tests/.gitkeep b/tests/.gitkeep deleted file mode 100644 index 139597f..0000000 --- a/tests/.gitkeep +++ /dev/null @@ -1,2 +0,0 @@ - - diff --git a/tests/test_generate_training_data.py b/tests/test_generate_training_data.py new file mode 100644 index 0000000..147600f --- /dev/null +++ b/tests/test_generate_training_data.py @@ -0,0 +1,387 @@ +""" +Unit tests for oumi/generate_training_data.py + +Tests the training data generation functions including pattern determination, +component generation, rationale generation, and example generation. +""" + +import sys +import os +import json +import pytest + +# Add oumi directory to path for imports +sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'oumi')) + +from generate_training_data import ( + determine_pattern, + generate_components, + generate_rationale, + generate_example, + PATTERNS, + DATABASES, + SERVICE_TYPES, +) + + +class TestDeterminePattern: + """Tests for the determine_pattern() function.""" + + def test_gpu_returns_kubernetes(self): + """Test GPU workloads return kubernetes pattern.""" + result = determine_pattern( + services=["api"], + db="postgres", + app_type="web", + gpu=True + ) + assert result == "kubernetes" + + def test_kafka_returns_event_driven(self): + """Test Kafka queue returns event_driven pattern.""" + result = determine_pattern( + services=["api", "worker"], + db="postgres", + app_type="web", + queue="kafka" + ) + assert result == "event_driven" + + def test_scheduled_single_service_serverless(self): + """Test scheduled single service returns serverless.""" + result = determine_pattern( + services=["cron-job"], + db="dynamodb", + app_type="scheduled", + scheduled=True + ) + assert result == "serverless" + + def test_single_service_dynamodb_serverless(self): + """Test single service with DynamoDB returns serverless.""" + result = determine_pattern( + services=["api"], + db="dynamodb", + app_type="web" + ) + assert result == "serverless" + + def test_five_services_kubernetes(self): + """Test 5+ services returns kubernetes.""" + result = determine_pattern( + services=["api", "web", "auth", "payments", "notifications"], + db="postgres", + app_type="web" + ) + assert result == "kubernetes" + + def test_six_services_kubernetes(self): + """Test 6 services returns kubernetes.""" + result = determine_pattern( + services=["api", "web", "auth", "payments", "notifications", "analytics"], + db="postgres", + app_type="web" + ) + assert result == "kubernetes" + + def test_two_services_microservices_ecs(self): + """Test 2 services returns microservices_ecs.""" + result = determine_pattern( + services=["api", "web"], + db="postgres", + app_type="web" + ) + assert result == "microservices_ecs" + + def test_three_services_microservices_ecs(self): + """Test 3 services returns microservices_ecs.""" + result = determine_pattern( + services=["api", "web", "worker"], + db="postgres", + app_type="web" + ) + assert result == "microservices_ecs" + + def test_four_services_microservices_ecs(self): + """Test 4 services returns microservices_ecs.""" + result = determine_pattern( + services=["api", "web", "worker", "auth"], + db="postgres", + app_type="web" + ) + assert result == "microservices_ecs" + + def test_single_legacy_lift_and_shift(self): + """Test single legacy service returns lift_and_shift.""" + result = determine_pattern( + services=["monolith"], + db="postgres", + app_type="legacy" + ) + assert result == "lift_and_shift" + + def test_single_enterprise_lift_and_shift(self): + """Test single enterprise service returns lift_and_shift.""" + result = determine_pattern( + services=["erp"], + db="postgres", + app_type="enterprise" + ) + assert result == "lift_and_shift" + + def test_single_service_default_serverless(self): + """Test single non-specific service defaults to serverless.""" + result = determine_pattern( + services=["api"], + db="postgres", + app_type="web" + ) + assert result == "serverless" + + +class TestGenerateComponents: + """Tests for the generate_components() function.""" + + def test_returns_list(self): + """Test that function returns a list.""" + result = generate_components("serverless", "dynamodb") + assert isinstance(result, list) + + def test_includes_base_pattern_components(self): + """Test that base pattern components are included.""" + result = generate_components("serverless", "dynamodb") + + # Serverless should have at least some base components + base_components = PATTERNS["serverless"]["components"] + for comp in base_components[:3]: # Check first few + # At least some should be present + pass # Components are included in base + + def test_adds_database_component(self): + """Test that appropriate database component is added.""" + result = generate_components("microservices_ecs", "postgres") + assert "rds" in result + + def test_dynamodb_mapping(self): + """Test DynamoDB component mapping.""" + result = generate_components("serverless", "dynamodb") + assert "dynamodb" in result + + def test_mongodb_mapping(self): + """Test MongoDB to DocumentDB mapping.""" + result = generate_components("microservices_ecs", "mongodb") + assert "documentdb" in result + + def test_redis_database_mapping(self): + """Test Redis to ElastiCache mapping.""" + result = generate_components("microservices_ecs", "redis") + assert "elasticache" in result + + def test_adds_queue_component(self): + """Test that queue component is added.""" + result = generate_components("event_driven", "postgres", queue="sqs") + assert "sqs" in result + + def test_kafka_queue_mapping(self): + """Test Kafka to MSK mapping.""" + result = generate_components("event_driven", "postgres", queue="kafka") + assert "msk" in result + + def test_rabbitmq_queue_mapping(self): + """Test RabbitMQ to Amazon MQ mapping.""" + result = generate_components("microservices_ecs", "postgres", queue="rabbitmq") + assert "amazon_mq" in result + + def test_no_duplicates(self): + """Test that returned components have no duplicates.""" + result = generate_components("kubernetes", "postgres", queue="redis") + assert len(result) == len(set(result)) + + def test_all_patterns_work(self): + """Test that all patterns can generate components.""" + for pattern in PATTERNS.keys(): + result = generate_components(pattern, "postgres") + assert isinstance(result, list) + assert len(result) > 0 + + +class TestGenerateRationale: + """Tests for the generate_rationale() function.""" + + def test_returns_string(self): + """Test that function returns a string.""" + result = generate_rationale( + pattern="serverless", + services=["api"], + db="dynamodb" + ) + assert isinstance(result, str) + + def test_string_not_empty(self): + """Test that rationale is not empty.""" + result = generate_rationale( + pattern="serverless", + services=["api"], + db="dynamodb" + ) + assert len(result) > 0 + + def test_all_patterns_have_rationales(self): + """Test that all patterns can generate rationales.""" + patterns = ["serverless", "microservices_ecs", "kubernetes", "event_driven", "lift_and_shift"] + + for pattern in patterns: + result = generate_rationale( + pattern=pattern, + services=["api"], + db="postgres" + ) + assert isinstance(result, str) + assert len(result) > 0 + + def test_unknown_pattern_has_fallback(self): + """Test that unknown patterns have a fallback rationale.""" + result = generate_rationale( + pattern="unknown_pattern", + services=["api"], + db="postgres" + ) + assert isinstance(result, str) + assert len(result) > 0 + + +class TestGenerateExample: + """Tests for the generate_example() function.""" + + def test_returns_dict(self): + """Test that function returns a dictionary.""" + result = generate_example() + assert isinstance(result, dict) + + def test_has_messages_key(self): + """Test that result has messages key.""" + result = generate_example() + assert "messages" in result + + def test_messages_is_list(self): + """Test that messages is a list.""" + result = generate_example() + assert isinstance(result["messages"], list) + + def test_has_three_messages(self): + """Test that there are exactly 3 messages (system, user, assistant).""" + result = generate_example() + assert len(result["messages"]) == 3 + + def test_message_roles_correct(self): + """Test that message roles are system, user, assistant.""" + result = generate_example() + messages = result["messages"] + + assert messages[0]["role"] == "system" + assert messages[1]["role"] == "user" + assert messages[2]["role"] == "assistant" + + def test_all_messages_have_content(self): + """Test that all messages have content.""" + result = generate_example() + + for message in result["messages"]: + assert "role" in message + assert "content" in message + assert len(message["content"]) > 0 + + def test_assistant_content_is_valid_json(self): + """Test that assistant content is valid JSON.""" + result = generate_example() + assistant_content = result["messages"][2]["content"] + + parsed = json.loads(assistant_content) + assert isinstance(parsed, dict) + + def test_assistant_json_has_architecture(self): + """Test that assistant JSON has architecture key.""" + result = generate_example() + assistant_content = result["messages"][2]["content"] + parsed = json.loads(assistant_content) + + assert "architecture" in parsed + + def test_architecture_has_required_keys(self): + """Test that architecture has required keys.""" + result = generate_example() + assistant_content = result["messages"][2]["content"] + parsed = json.loads(assistant_content) + + architecture = parsed["architecture"] + assert "pattern" in architecture + assert "components" in architecture + assert "rationale" in architecture + + def test_has_inputs_key(self): + """Test that assistant JSON has inputs key.""" + result = generate_example() + assistant_content = result["messages"][2]["content"] + parsed = json.loads(assistant_content) + + assert "inputs" in parsed + assert "service_count" in parsed["inputs"] + assert "cloud_provider" in parsed["inputs"] + + def test_has_source_key(self): + """Test that assistant JSON has source key.""" + result = generate_example() + assistant_content = result["messages"][2]["content"] + parsed = json.loads(assistant_content) + + assert "source" in parsed + assert parsed["source"] == "ai_recommendation" + + def test_pattern_is_valid(self): + """Test that pattern is one of the valid patterns.""" + valid_patterns = list(PATTERNS.keys()) + + for _ in range(10): # Run multiple times due to randomness + result = generate_example() + assistant_content = result["messages"][2]["content"] + parsed = json.loads(assistant_content) + + pattern = parsed["architecture"]["pattern"] + assert pattern in valid_patterns + + def test_components_are_strings(self): + """Test that components is a list of strings.""" + result = generate_example() + assistant_content = result["messages"][2]["content"] + parsed = json.loads(assistant_content) + + components = parsed["architecture"]["components"] + assert isinstance(components, list) + + for comp in components: + assert isinstance(comp, str) + + def test_user_content_contains_services(self): + """Test that user content contains 'Services:' info.""" + result = generate_example() + user_content = result["messages"][1]["content"] + + assert "Services:" in user_content + + def test_user_content_contains_db(self): + """Test that user content contains 'DB:' info.""" + result = generate_example() + user_content = result["messages"][1]["content"] + + assert "DB:" in user_content + + def test_user_content_contains_cloud(self): + """Test that user content contains 'Cloud:' info.""" + result = generate_example() + user_content = result["messages"][1]["content"] + + assert "Cloud:" in user_content + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/tests/test_kestra.js b/tests/test_kestra.js new file mode 100644 index 0000000..3588876 --- /dev/null +++ b/tests/test_kestra.js @@ -0,0 +1,260 @@ +/** + * Unit tests for ui/lib/kestra.js + * + * Tests the Kestra API utility functions including state mapping, + * step progress mapping, and duration calculation. + * + * Run with: node test_kestra.js + */ + +import assert from 'node:assert'; +import { describe, it } from 'node:test'; + +// Import the functions to test +import { + PIPELINE_STEPS, + STATE_MAP, + mapToStepProgress, + calculateDuration, +} from '../ui/lib/kestra.js'; + + +describe('PIPELINE_STEPS', () => { + it('should have 9 pipeline steps', () => { + assert.strictEqual(PIPELINE_STEPS.length, 9); + }); + + it('should have correct step IDs', () => { + const expectedIds = [ + 'ingest_repo', + 'ingest_telemetry', + 'propose_architecture', + 'render_graph', + 'generate_iac', + 'validate_iac', + 'create_pr', + 'validate_pr', + 'evaluate', + ]; + + const actualIds = PIPELINE_STEPS.map(step => step.id); + assert.deepStrictEqual(actualIds, expectedIds); + }); + + it('should have sequential order values', () => { + for (let i = 0; i < PIPELINE_STEPS.length; i++) { + assert.strictEqual(PIPELINE_STEPS[i].order, i + 1); + } + }); + + it('should have label for each step', () => { + for (const step of PIPELINE_STEPS) { + assert.ok(step.label, `Step ${step.id} should have a label`); + assert.ok(typeof step.label === 'string', `Step ${step.id} label should be string`); + } + }); +}); + + +describe('STATE_MAP', () => { + it('should map CREATED to pending', () => { + assert.strictEqual(STATE_MAP.CREATED, 'pending'); + }); + + it('should map QUEUED to pending', () => { + assert.strictEqual(STATE_MAP.QUEUED, 'pending'); + }); + + it('should map RUNNING to running', () => { + assert.strictEqual(STATE_MAP.RUNNING, 'running'); + }); + + it('should map SUCCESS to completed', () => { + assert.strictEqual(STATE_MAP.SUCCESS, 'completed'); + }); + + it('should map WARNING to completed', () => { + assert.strictEqual(STATE_MAP.WARNING, 'completed'); + }); + + it('should map FAILED to failed', () => { + assert.strictEqual(STATE_MAP.FAILED, 'failed'); + }); + + it('should map RETRYING to running', () => { + assert.strictEqual(STATE_MAP.RETRYING, 'running'); + }); + + it('should map PAUSED to pending', () => { + assert.strictEqual(STATE_MAP.PAUSED, 'pending'); + }); + + it('should map KILLED to failed', () => { + assert.strictEqual(STATE_MAP.KILLED, 'failed'); + }); + + it('should have all expected states', () => { + const expectedStates = ['CREATED', 'QUEUED', 'RUNNING', 'SUCCESS', 'WARNING', 'FAILED', 'RETRYING', 'PAUSED', 'KILLED']; + for (const state of expectedStates) { + assert.ok(state in STATE_MAP, `STATE_MAP should include ${state}`); + } + }); +}); + + +describe('mapToStepProgress', () => { + it('should return array with same length as PIPELINE_STEPS', () => { + const executionData = { taskRuns: [] }; + const result = mapToStepProgress(executionData); + + assert.strictEqual(result.length, PIPELINE_STEPS.length); + }); + + it('should return pending state for missing tasks', () => { + const executionData = { taskRuns: [] }; + const result = mapToStepProgress(executionData); + + for (const step of result) { + assert.strictEqual(step.state, 'pending'); + } + }); + + it('should return empty outputs for missing tasks', () => { + const executionData = { taskRuns: [] }; + const result = mapToStepProgress(executionData); + + for (const step of result) { + assert.deepStrictEqual(step.outputs, {}); + } + }); + + it('should map task run states correctly', () => { + const executionData = { + taskRuns: [ + { id: 'ingest_repo', state: 'SUCCESS', outputs: { result: 'done' } } + ] + }; + + const result = mapToStepProgress(executionData); + const ingestStep = result.find(s => s.id === 'ingest_repo'); + + assert.strictEqual(ingestStep.state, 'SUCCESS'); + assert.deepStrictEqual(ingestStep.outputs, { result: 'done' }); + }); + + it('should include startDate and endDate from task runs', () => { + const startDate = '2024-01-01T10:00:00Z'; + const endDate = '2024-01-01T10:01:00Z'; + + const executionData = { + taskRuns: [ + { id: 'ingest_repo', state: 'SUCCESS', startDate, endDate, outputs: {} } + ] + }; + + const result = mapToStepProgress(executionData); + const ingestStep = result.find(s => s.id === 'ingest_repo'); + + assert.strictEqual(ingestStep.startDate, startDate); + assert.strictEqual(ingestStep.endDate, endDate); + }); + + it('should preserve original step properties', () => { + const executionData = { taskRuns: [] }; + const result = mapToStepProgress(executionData); + + for (let i = 0; i < result.length; i++) { + assert.strictEqual(result[i].id, PIPELINE_STEPS[i].id); + assert.strictEqual(result[i].label, PIPELINE_STEPS[i].label); + assert.strictEqual(result[i].order, PIPELINE_STEPS[i].order); + } + }); + + it('should handle multiple task runs', () => { + const executionData = { + taskRuns: [ + { id: 'ingest_repo', state: 'SUCCESS', outputs: {} }, + { id: 'ingest_telemetry', state: 'RUNNING', outputs: {} }, + { id: 'propose_architecture', state: 'QUEUED', outputs: {} }, + ] + }; + + const result = mapToStepProgress(executionData); + + assert.strictEqual(result.find(s => s.id === 'ingest_repo').state, 'SUCCESS'); + assert.strictEqual(result.find(s => s.id === 'ingest_telemetry').state, 'RUNNING'); + assert.strictEqual(result.find(s => s.id === 'propose_architecture').state, 'QUEUED'); + assert.strictEqual(result.find(s => s.id === 'render_graph').state, 'pending'); + }); +}); + + +describe('calculateDuration', () => { + it('should return null if startDate is missing', () => { + const result = calculateDuration(null, '2024-01-01T10:01:00Z'); + assert.strictEqual(result, null); + }); + + it('should return null if endDate is missing', () => { + const result = calculateDuration('2024-01-01T10:00:00Z', null); + assert.strictEqual(result, null); + }); + + it('should return null if both dates are missing', () => { + const result = calculateDuration(null, null); + assert.strictEqual(result, null); + }); + + it('should return milliseconds for sub-second durations', () => { + const startDate = '2024-01-01T10:00:00.000Z'; + const endDate = '2024-01-01T10:00:00.500Z'; + + const result = calculateDuration(startDate, endDate); + assert.strictEqual(result, '500ms'); + }); + + it('should return seconds for sub-minute durations', () => { + const startDate = '2024-01-01T10:00:00Z'; + const endDate = '2024-01-01T10:00:30Z'; + + const result = calculateDuration(startDate, endDate); + assert.strictEqual(result, '30s'); + }); + + it('should return minutes for sub-hour durations', () => { + const startDate = '2024-01-01T10:00:00Z'; + const endDate = '2024-01-01T10:05:00Z'; + + const result = calculateDuration(startDate, endDate); + assert.strictEqual(result, '5m'); + }); + + it('should return hours for long durations', () => { + const startDate = '2024-01-01T10:00:00Z'; + const endDate = '2024-01-01T12:00:00Z'; + + const result = calculateDuration(startDate, endDate); + assert.strictEqual(result, '2h'); + }); + + it('should round seconds correctly', () => { + const startDate = '2024-01-01T10:00:00Z'; + const endDate = '2024-01-01T10:00:45Z'; + + const result = calculateDuration(startDate, endDate); + assert.strictEqual(result, '45s'); + }); + + it('should round minutes correctly', () => { + const startDate = '2024-01-01T10:00:00Z'; + const endDate = '2024-01-01T10:30:00Z'; + + const result = calculateDuration(startDate, endDate); + assert.strictEqual(result, '30m'); + }); +}); + + +// Run tests summary +console.log('\nβœ… All Kestra utility tests defined'); +console.log('Run with: node --test tests/test_kestra.js\n'); diff --git a/tests/test_mcp_server.mjs b/tests/test_mcp_server.mjs new file mode 100644 index 0000000..f9abcca --- /dev/null +++ b/tests/test_mcp_server.mjs @@ -0,0 +1,110 @@ +#!/usr/bin/env node +/** + * MCP Server Integration Test + * Tests all 9 InFoundry workflow tools via the MCP protocol + */ + +import { spawn } from 'child_process'; +import * as readline from 'readline'; +import * as path from 'path'; +import { fileURLToPath } from 'url'; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = path.dirname(__filename); +const projectRoot = path.resolve(__dirname, '..'); +const mcpServerDir = path.join(projectRoot, 'infoundry-mcp-server'); + +const server = spawn('node', ['dist/index.js'], { + cwd: mcpServerDir, + stdio: ['pipe', 'pipe', 'pipe'] +}); + +let messageId = 1; + +function sendRequest(method, params = {}) { + const request = { jsonrpc: '2.0', id: messageId++, method, params }; + console.log(`\nβ†’ [${request.id}] ${params.name || method}`); + server.stdin.write(JSON.stringify(request) + '\n'); +} + +const rl = readline.createInterface({ input: server.stdout }); +rl.on('line', (line) => { + try { + const response = JSON.parse(line); + const content = response.result?.content?.[0]?.text; + if (content) { + const parsed = JSON.parse(content); + const preview = JSON.stringify(parsed, null, 2).slice(0, 400); + console.log(`← Response:`, preview, preview.length >= 400 ? '...' : ''); + console.log(response.result?.isError ? ' ⚠️ Error' : ' βœ… Success'); + } else if (response.result?.tools) { + console.log(`← Found ${response.result.tools.length} tools:`, response.result.tools.map(t => t.name).join(', ')); + } + } catch { } +}); + +server.stderr.on('data', (data) => { + const msg = data.toString().trim(); + if (msg.includes('running')) console.log('πŸš€', msg); +}); + +// Test data +const sampleProfile = JSON.stringify({ + services: { api: { type: 'python' }, web: { type: 'nodejs' } }, + databases: ['postgres'], + queues: ['redis'], + service_count: 2, + primary_language: 'python' +}); + +console.log('\n╔════════════════════════════════════════════════════════╗'); +console.log('β•‘ InFoundry MCP Server - 9 Workflow Steps Test β•‘'); +console.log('β•šβ•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•'); + +setTimeout(() => sendRequest('tools/list'), 500); + +setTimeout(() => { + console.log('\n━━━ Step 1: ingest_repo ━━━'); + sendRequest('tools/call', { name: 'ingest_repo', arguments: { repoPath: projectRoot } }); +}, 1000); + +setTimeout(() => { + console.log('\n━━━ Step 2: ingest_telemetry ━━━'); + sendRequest('tools/call', { name: 'ingest_telemetry', arguments: { services: 'api,web,db' } }); +}, 2000); + +setTimeout(() => { + console.log('\n━━━ Step 3: propose_architecture ━━━'); + sendRequest('tools/call', { name: 'propose_architecture', arguments: { serviceProfile: sampleProfile } }); +}, 3000); + +setTimeout(() => { + const archPlan = JSON.stringify({ + architecture: { pattern: 'serverless', components: ['api_gateway', 'lambda_functions', 'dynamodb', 'rds'] }, + source: 'test' + }); + console.log('\n━━━ Step 4: render_graph ━━━'); + sendRequest('tools/call', { name: 'render_graph', arguments: { architecturePlan: archPlan } }); +}, 4000); + +setTimeout(() => { + const graph = JSON.stringify({ + nodes: [{ id: 'api_gateway' }, { id: 'lambda_functions' }], + metadata: { pattern: 'serverless' } + }); + console.log('\n━━━ Step 5: generate_iac ━━━'); + sendRequest('tools/call', { name: 'generate_iac', arguments: { graph, projectName: 'test' } }); +}, 5000); + +setTimeout(() => { + console.log('\n━━━ Step 6-9: validate_iac, create_pr, validate_pr, evaluate ━━━'); + console.log(' ℹ️ Skipped (require terraform/GITHUB_TOKEN)'); +}, 6000); + +setTimeout(() => { + console.log('\n╔════════════════════════════════════════════════════════╗'); + console.log('β•‘ All Tests Complete! β•‘'); + console.log('β•šβ•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•\n'); + server.kill(); + process.exit(0); +}, 7000); diff --git a/tests/test_oumi_serve.py b/tests/test_oumi_serve.py new file mode 100644 index 0000000..c040697 --- /dev/null +++ b/tests/test_oumi_serve.py @@ -0,0 +1,292 @@ +""" +Unit tests for oumi/serve.py + +Tests the FastAPI server endpoints and heuristic response function. +Uses FastAPI's TestClient for endpoint testing. +""" + +import sys +import os +import json +import pytest + +# Add oumi directory to path for imports +sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'oumi')) + +# Import the FastAPI app and functions +from serve import app, heuristic_response + +# Import TestClient for API testing +from fastapi.testclient import TestClient + +client = TestClient(app) + + +class TestHeuristicResponse: + """Tests for the heuristic_response() function.""" + + def test_returns_dict_with_required_keys(self): + """Test that function returns dict with pattern, components, rationale.""" + result = heuristic_response("test prompt") + + assert isinstance(result, dict) + assert "pattern" in result + assert "components" in result + assert "rationale" in result + + def test_kafka_pattern_detection(self): + """Test that kafka triggers event_driven pattern.""" + result = heuristic_response("my app uses kafka") + + assert result["pattern"] == "event_driven" + assert "msk" in result["components"] + + def test_queue_pattern_detection(self): + """Test that queue keyword triggers event_driven pattern.""" + result = heuristic_response("need a message queue system") + + assert result["pattern"] == "event_driven" + + def test_kubernetes_pattern_detection(self): + """Test that kubernetes keyword triggers kubernetes pattern.""" + result = heuristic_response("deploy on kubernetes cluster") + + assert result["pattern"] == "kubernetes" + assert "eks_cluster" in result["components"] + + def test_five_services_kubernetes(self): + """Test that 5+ services triggers kubernetes pattern.""" + result = heuristic_response("we have 5 microservices") + + assert result["pattern"] == "kubernetes" + + def test_six_services_kubernetes(self): + """Test that 6+ services triggers kubernetes pattern.""" + result = heuristic_response("we have 6 microservices") + + assert result["pattern"] == "kubernetes" + + def test_serverless_pattern_detection(self): + """Test that serverless keyword triggers serverless pattern.""" + result = heuristic_response("want a serverless backend") + + assert result["pattern"] == "serverless" + assert "api_gateway" in result["components"] + assert "lambda_functions" in result["components"] + + def test_lambda_pattern_detection(self): + """Test that lambda keyword triggers serverless pattern.""" + result = heuristic_response("deploy lambda functions") + + assert result["pattern"] == "serverless" + + def test_default_microservices_ecs(self): + """Test default pattern when no specific keywords match.""" + result = heuristic_response("build a simple web app") + + assert result["pattern"] == "microservices_ecs" + assert "ecs_cluster" in result["components"] + + def test_high_latency_adds_components(self): + """Test that 'high' keyword adds extra components.""" + result = heuristic_response("need high performance") + + # Should add elasticache, cdn, or hpa + extended_components = ["elasticache", "cdn", "hpa"] + has_extended = any(c in result["components"] for c in extended_components) + assert has_extended + + def test_latency_keyword_adds_components(self): + """Test that 'latency' keyword adds extra components.""" + result = heuristic_response("low latency is important") + + extended_components = ["elasticache", "cdn", "hpa"] + has_extended = any(c in result["components"] for c in extended_components) + assert has_extended + + def test_components_are_unique(self): + """Test that components list has no duplicates.""" + result = heuristic_response("high latency kubernetes cluster") + + components = result["components"] + assert len(components) == len(set(components)) + + def test_rationale_contains_pattern(self): + """Test that rationale mentions the selected pattern.""" + result = heuristic_response("test prompt") + + assert result["pattern"] in result["rationale"] + + +class TestHealthEndpoint: + """Tests for the /health endpoint.""" + + def test_health_returns_200(self): + """Test that health endpoint returns HTTP 200.""" + response = client.get("/health") + + assert response.status_code == 200 + + def test_health_response_structure(self): + """Test that health response has required keys.""" + response = client.get("/health") + data = response.json() + + assert "status" in data + assert "ollama_available" in data + assert "ollama_url" in data + + def test_health_status_is_healthy(self): + """Test that status is 'healthy'.""" + response = client.get("/health") + data = response.json() + + assert data["status"] == "healthy" + + def test_ollama_available_is_boolean(self): + """Test that ollama_available is a boolean.""" + response = client.get("/health") + data = response.json() + + assert isinstance(data["ollama_available"], bool) + + +class TestChatCompletionsEndpoint: + """Tests for the /v1/chat/completions endpoint.""" + + def test_returns_200_with_messages(self): + """Test endpoint returns 200 with valid messages input.""" + response = client.post( + "/v1/chat/completions", + json={ + "model": "test", + "messages": [{"role": "user", "content": "build a simple api"}] + } + ) + + assert response.status_code == 200 + + def test_returns_200_with_prompt(self): + """Test endpoint returns 200 with prompt input.""" + response = client.post( + "/v1/chat/completions", + json={ + "model": "test", + "prompt": "build a simple api" + } + ) + + assert response.status_code == 200 + + def test_returns_400_without_prompt(self): + """Test endpoint returns 400 when no prompt provided.""" + response = client.post( + "/v1/chat/completions", + json={"model": "test"} + ) + + assert response.status_code == 400 + + def test_response_has_correct_id(self): + """Test response has cmpl-infoundry id.""" + response = client.post( + "/v1/chat/completions", + json={"prompt": "test"} + ) + data = response.json() + + assert data["id"] == "cmpl-infoundry" + + def test_response_has_choices(self): + """Test response has choices array with message.""" + response = client.post( + "/v1/chat/completions", + json={"prompt": "test"} + ) + data = response.json() + + assert "choices" in data + assert len(data["choices"]) > 0 + assert "message" in data["choices"][0] + + def test_message_role_is_assistant(self): + """Test message role is assistant.""" + response = client.post( + "/v1/chat/completions", + json={"prompt": "test"} + ) + data = response.json() + + message = data["choices"][0]["message"] + assert message["role"] == "assistant" + + def test_finish_reason_is_stop(self): + """Test finish_reason is stop.""" + response = client.post( + "/v1/chat/completions", + json={"prompt": "test"} + ) + data = response.json() + + assert data["choices"][0]["finish_reason"] == "stop" + + def test_content_is_valid_json(self): + """Test that message content is valid JSON (heuristic fallback).""" + response = client.post( + "/v1/chat/completions", + json={"prompt": "simple web service"} + ) + data = response.json() + + content = data["choices"][0]["message"]["content"] + # Should be able to parse as JSON + parsed = json.loads(content) + assert "pattern" in parsed + + +class TestCompletionsEndpoint: + """Tests for the /v1/completions endpoint.""" + + def test_returns_200(self): + """Test endpoint returns 200 with prompt.""" + response = client.post( + "/v1/completions", + json={"prompt": "build an api"} + ) + + assert response.status_code == 200 + + def test_response_has_choices(self): + """Test response has choices array.""" + response = client.post( + "/v1/completions", + json={"prompt": "build an api"} + ) + data = response.json() + + assert "choices" in data + assert len(data["choices"]) > 0 + + def test_choice_has_text(self): + """Test that choice has text field.""" + response = client.post( + "/v1/completions", + json={"prompt": "build an api"} + ) + data = response.json() + + assert "text" in data["choices"][0] + + def test_finish_reason_is_stop(self): + """Test finish_reason is stop.""" + response = client.post( + "/v1/completions", + json={"prompt": "test"} + ) + data = response.json() + + assert data["choices"][0]["finish_reason"] == "stop" + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/ui/.env.example b/ui/.env.example new file mode 100644 index 0000000..c3d93ca --- /dev/null +++ b/ui/.env.example @@ -0,0 +1,12 @@ +# Kestra API URL (default: http://localhost:8080) +KESTRA_API_URL=http://localhost:8080 + +# Kestra Tenant (default: main) +KESTRA_TENANT=main + +# Authentication (Option 1: API Token) +# KESTRA_API_TOKEN=your-api-token-here + +# Authentication (Option 2: Username/Password) +# KESTRA_USERNAME=your-username +# KESTRA_PASSWORD=your-password diff --git a/ui/README.md b/ui/README.md new file mode 100644 index 0000000..1ff1516 --- /dev/null +++ b/ui/README.md @@ -0,0 +1,55 @@ +# InFoundry UI + +Next.js 15 dashboard for InFoundry cloud architecture platform. + +## Features +- πŸ—οΈ Visual Architecture Editor (React Flow) +- πŸ“Š Kestra Pipeline Monitoring +- βš™οΈ Service Configuration Generator +- πŸ“ˆ Real-time Step Progress Tracking + +## Development + +```bash +cd ui +npm install +npm run dev +``` + +Open [http://localhost:3000](http://localhost:3000) to view the dashboard. + +## Pages + +| Route | Description | +|-------|-------------| +| `/` | Landing page with feature overview | +| `/dashboard` | Architecture diagram editor | +| `/pipeline` | Kestra pipeline runner & monitor | +| `/configure` | Service profile configuration | + +## Environment Variables + +Copy `.env.example` to `.env.local` and update the values: + + ```bash + cp .env.example .env.local + ``` + + Variables: + - `KESTRA_API_URL`: URL of the Kestra API (default: `http://localhost:8080`) + - `KESTRA_TENANT`: Kestra tenant ID (default: `main`) + - `KESTRA_API_TOKEN`: Optional API token for authentication + - `KESTRA_USERNAME` / `KESTRA_PASSWORD`: Optional credentials for basic auth + +## Build + +```bash +npm run build +npm start +``` + +## Deploy on Vercel + +[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new?utm_medium=default-template&filter=next.js) + +Check [Next.js deployment docs](https://nextjs.org/docs/app/building-your-application/deploying) for details. diff --git a/ui/app/api/kestra/execute/route.js b/ui/app/api/kestra/execute/route.js new file mode 100644 index 0000000..21b03bf --- /dev/null +++ b/ui/app/api/kestra/execute/route.js @@ -0,0 +1,103 @@ +import { NextResponse } from 'next/server'; + +// Kestra API configuration +const KESTRA_API_URL = process.env.KESTRA_API_URL || 'http://localhost:8080'; +const KESTRA_TENANT = process.env.KESTRA_TENANT || 'main'; +const KESTRA_NAMESPACE = 'infoundry'; + +/** + * Build HTTP authorization headers using available Kestra credentials. + * + * Prefers the API token (KESTRA_API_TOKEN) and falls back to Basic Auth using + * KESTRA_USERNAME and KESTRA_PASSWORD if the token is not present. + * + * @returns {{[header: string]: string}} An object containing an `Authorization` + * header when credentials are available, or an empty object otherwise. + */ +function getAuthHeaders() { + const headers = {}; + + // Option 1: API Token (Bearer) + if (process.env.KESTRA_API_TOKEN) { + headers['Authorization'] = `Bearer ${process.env.KESTRA_API_TOKEN}`; + } + // Option 2: Basic Auth (username:password) + else if (process.env.KESTRA_USERNAME && process.env.KESTRA_PASSWORD) { + const credentials = Buffer.from( + `${process.env.KESTRA_USERNAME}:${process.env.KESTRA_PASSWORD}` + ).toString('base64'); + headers['Authorization'] = `Basic ${credentials}`; + } + + return headers; +} + +/** + * Trigger a Kestra end-to-end pipeline using inputs from the incoming request. + * + * Expects a JSON body containing pipeline inputs; `repo_url` is required. + * + * @param {Request} request - Incoming HTTP request whose JSON body provides pipeline inputs (e.g., `repo_url`, `branch`, `repository`, `cloud_provider`, `project_name`, `target_folder`, `skip_pr`, `skip_validation`). + * @returns {import('next/server').NextResponse} JSON response containing `executionId`, `state`, and a success message on success; on error returns a JSON object with `error` and `details` (or `message`) and an appropriate HTTP status. + */ +export async function POST(request) { + try { + const inputs = await request.json(); + + // Validate required inputs + if (!inputs.repo_url) { + return NextResponse.json( + { error: 'repo_url is required' }, + { status: 400 } + ); + } + + // Kestra API requires multipart/form-data for inputs + // URL format: /api/v1/{tenant}/executions/{namespace}/{flowId} + const kestraUrl = `${KESTRA_API_URL}/api/v1/${KESTRA_TENANT}/executions/${KESTRA_NAMESPACE}/end-to-end`; + + // Build FormData with inputs + const formData = new FormData(); + formData.append('repo_url', inputs.repo_url); + formData.append('branch', inputs.branch || 'main'); + formData.append('repository', inputs.repository || 'crypticsaiyan/infotest'); + formData.append('cloud_provider', inputs.cloud_provider || 'aws'); + formData.append('project_name', inputs.project_name || 'infoundry'); + formData.append('target_folder', inputs.target_folder || 'infra'); + formData.append('skip_pr', String(inputs.skip_pr || false)); + formData.append('skip_validation', String(inputs.skip_validation || false)); + + const response = await fetch(kestraUrl, { + method: 'POST', + headers: { + ...getAuthHeaders(), + // Note: Don't set Content-Type, fetch will set it with boundary for FormData + }, + body: formData, + }); + + if (!response.ok) { + const errorText = await response.text(); + console.error('Kestra API error:', errorText); + return NextResponse.json( + { error: 'Failed to trigger pipeline', details: errorText }, + { status: response.status } + ); + } + + const data = await response.json(); + + return NextResponse.json({ + executionId: data.id, + state: data.state?.current || 'CREATED', + message: 'Pipeline triggered successfully', + }); + + } catch (error) { + console.error('Error triggering pipeline:', error); + return NextResponse.json( + { error: 'Internal server error', message: error.message }, + { status: 500 } + ); + } +} \ No newline at end of file diff --git a/ui/app/api/kestra/file/route.js b/ui/app/api/kestra/file/route.js new file mode 100644 index 0000000..f0e714c --- /dev/null +++ b/ui/app/api/kestra/file/route.js @@ -0,0 +1,131 @@ +import { NextResponse } from 'next/server'; + +// Kestra API configuration +const KESTRA_API_URL = process.env.KESTRA_API_URL || 'http://localhost:8080'; +const KESTRA_TENANT = process.env.KESTRA_TENANT || 'main'; + +/** + * Build HTTP authentication headers for Kestra using available environment credentials. + * + * Prefers an API token when KESTRA_API_TOKEN is set; otherwise uses Basic auth when + * KESTRA_USERNAME and KESTRA_PASSWORD are provided. If no credentials are available, + * returns an empty object. + * + * @returns {Object} An object containing an `Authorization` header (`Bearer ` or `Basic `) or an empty object if no credentials are configured. + */ +function getAuthHeaders() { + const headers = {}; + + if (process.env.KESTRA_API_TOKEN) { + headers['Authorization'] = `Bearer ${process.env.KESTRA_API_TOKEN}`; + } else if (process.env.KESTRA_USERNAME && process.env.KESTRA_PASSWORD) { + const credentials = Buffer.from( + `${process.env.KESTRA_USERNAME}:${process.env.KESTRA_PASSWORD}` + ).toString('base64'); + headers['Authorization'] = `Basic ${credentials}`; + } + + return headers; +} + +/** + * Extract the execution ID from a Kestra internal URI. + * + * @param {string} uri - Kestra internal URI (e.g., "kestra:///namespace/flowId/executions/EXEC_ID/tasks/..."). + * @returns {string|null} The execution ID string if found, `null` otherwise. + */ +function extractExecutionId(uri) { + const match = uri.match(/executions\/([^\/]+)/); + return match ? match[1] : null; +} + +/** + * Handle GET /api/kestra/file?uri=... and return the content of a Kestra-stored file. + * + * Processes the `uri` query parameter to extract an execution ID, proxies a request to the Kestra + * file API, and returns one of: + * - the parsed JSON file content (when the file is valid JSON), + * - { type: 'text', content } for plain-text content, + * - { type: 'binary', contentType, size, message } for large/binary responses, + * or an error JSON when the `uri` is missing/invalid, Kestra responds with an error, or an internal + * error occurs. + * + * @param {Request} request - Incoming request containing the `uri` query parameter. + * @returns {import('next/server').NextResponse} JSON response with the file content or an error object. + */ +export async function GET(request) { + try { + const { searchParams } = new URL(request.url); + const uri = searchParams.get('uri'); + + if (!uri) { + return NextResponse.json( + { error: 'uri parameter is required' }, + { status: 400 } + ); + } + + // Extract execution ID from the URI + const executionId = extractExecutionId(uri); + + if (!executionId) { + return NextResponse.json( + { error: 'Could not extract execution ID from URI', uri }, + { status: 400 } + ); + } + + // Correct Kestra API endpoint: /api/v1/{tenant}/executions/{executionId}/file?path={full_kestra_uri} + const kestraUrl = `${KESTRA_API_URL}/api/v1/${KESTRA_TENANT}/executions/${executionId}/file?path=${encodeURIComponent(uri)}`; + + console.log('Fetching file from:', kestraUrl); + + const response = await fetch(kestraUrl, { + method: 'GET', + headers: { + ...getAuthHeaders(), + }, + }); + + if (!response.ok) { + const errorText = await response.text(); + console.error('Kestra file fetch error:', errorText); + return NextResponse.json( + { error: 'Failed to fetch file', details: errorText, uri }, + { status: response.status } + ); + } + + const contentType = response.headers.get('content-type') || ''; + + // Always try to get the text content first + const text = await response.text(); + + // Try to parse as JSON (even for octet-stream, Kestra often returns JSON this way) + try { + const json = JSON.parse(text); + return NextResponse.json(json); + } catch { + // Only treat as binary if it's actually binary (not parseable as JSON) + if (contentType.includes('application/zip') || + (contentType.includes('octet-stream') && text.length > 10000)) { + return NextResponse.json({ + type: 'binary', + contentType, + size: response.headers.get('content-length'), + message: 'Binary file - download from Kestra UI', + }); + } + + // Return as plain text + return NextResponse.json({ type: 'text', content: text }); + } + + } catch (error) { + console.error('Error fetching file:', error); + return NextResponse.json( + { error: 'Internal server error', message: error.message }, + { status: 500 } + ); + } +} \ No newline at end of file diff --git a/ui/app/api/kestra/status/[executionId]/route.js b/ui/app/api/kestra/status/[executionId]/route.js new file mode 100644 index 0000000..6f52d91 --- /dev/null +++ b/ui/app/api/kestra/status/[executionId]/route.js @@ -0,0 +1,157 @@ +import { NextResponse } from 'next/server'; +import { STATE_MAP } from '@/lib/kestra'; + +// Pin to Node.js runtime (required for Buffer usage) +export const runtime = 'nodejs'; + +// Kestra API configuration +const KESTRA_API_URL = process.env.KESTRA_API_URL || 'http://localhost:8080'; +const KESTRA_TENANT = process.env.KESTRA_TENANT || 'main'; +const FETCH_TIMEOUT_MS = 10000; // 10 second timeout + +/** + * Build request headers containing an Authorization entry for Kestra based on available environment credentials. + * + * Prefers a bearer token from `KESTRA_API_TOKEN`; if absent, uses Basic auth from `KESTRA_USERNAME` and `KESTRA_PASSWORD`. Returns an empty object when no credentials are configured. + * @returns {Object} An object of HTTP headers; includes an `Authorization` header when credentials are available. + */ +function getAuthHeaders() { + const headers = {}; + + // Option 1: API Token (Bearer) + if (process.env.KESTRA_API_TOKEN) { + headers['Authorization'] = `Bearer ${process.env.KESTRA_API_TOKEN}`; + } + // Option 2: Basic Auth (username:password) + else if (process.env.KESTRA_USERNAME && process.env.KESTRA_PASSWORD) { + const credentials = Buffer.from( + `${process.env.KESTRA_USERNAME}:${process.env.KESTRA_PASSWORD}` + ).toString('base64'); + headers['Authorization'] = `Basic ${credentials}`; + } + + return headers; +} + +/** + * Fetches and returns a normalized Kestra execution status for the provided executionId. + * + * @param {Request} request - The incoming Next.js request object. + * @param {{ params: { executionId?: string } }} context - Route context containing path parameters. + * @param {Object} context.params.executionId - The execution identifier extracted from the route. + * @returns {Object} A JSON payload with the execution summary: + * - executionId: The Kestra execution id. + * - state: Mapped, frontend-friendly execution state (defaults to "pending" if unknown). + * - rawState: The original Kestra execution state string. + * - startDate: Execution start timestamp (if available). + * - endDate: Execution end timestamp (if available). + * - taskRuns: Array of normalized task run objects, each with: + * - id: Task id. + * - state: Mapped task state (defaults to "pending" if unknown). + * - rawState: Original Kestra task state string. + * - startDate: Task start timestamp (if available). + * - endDate: Task end timestamp (if available). + * - outputs: Task outputs with nested `outputs` flattened when present. + * - error: Task error payload when the raw state is "FAILED", otherwise `null`. + * - outputs: Execution-level outputs object (empty object when absent). + */ +export async function GET(request, { params }) { + try { + const { executionId } = await params; + + if (!executionId) { + return NextResponse.json( + { error: 'executionId is required' }, + { status: 400 } + ); + } + + // URL-encode the executionId to prevent injection/malformed URLs + const encodedExecutionId = encodeURIComponent(executionId); + + // URL format: /api/v1/{tenant}/executions/{executionId} + const kestraUrl = `${KESTRA_API_URL}/api/v1/${KESTRA_TENANT}/executions/${encodedExecutionId}`; + + // Create AbortController for timeout + const controller = new AbortController(); + const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS); + + let response; + try { + response = await fetch(kestraUrl, { + method: 'GET', + headers: { + 'Accept': 'application/json', + ...getAuthHeaders(), + }, + signal: controller.signal, + }); + } catch (fetchError) { + clearTimeout(timeoutId); + // Handle timeout or network errors + if (fetchError.name === 'AbortError') { + console.error('Kestra API timeout:', kestraUrl); + return NextResponse.json( + { error: 'Request timed out. Please try again.' }, + { status: 504 } + ); + } + throw fetchError; + } finally { + clearTimeout(timeoutId); + } + + if (!response.ok) { + // Log detailed error on server, return generic message to client + const errorText = await response.text(); + console.error('Kestra API error:', { + status: response.status, + url: kestraUrl, + body: errorText, + }); + return NextResponse.json( + { error: 'Failed to fetch execution status. Please try again.' }, + { status: response.status >= 500 ? 502 : response.status } + ); + } + + const data = await response.json(); + + // Normalize task runs for frontend consumption + // Note: Kestra outputs have structure {state, outputs: {...}, executionId} + // We need to extract the inner 'outputs' object + const taskRuns = (data.taskRunList || []).map(task => { + // Extract the actual outputs from the nested structure + const rawOutputs = task.outputs || {}; + const actualOutputs = rawOutputs.outputs || rawOutputs; + + return { + id: task.taskId, + state: STATE_MAP[task.state?.current] || 'pending', + rawState: task.state?.current, + startDate: task.state?.startDate, + endDate: task.state?.endDate, + outputs: actualOutputs, + error: task.state?.current === 'FAILED' ? task.outputs?.error : null, + }; + }); + + return NextResponse.json({ + executionId: data.id, + state: STATE_MAP[data.state?.current] || 'pending', + rawState: data.state?.current, + startDate: data.state?.startDate, + endDate: data.state?.endDate, + taskRuns, + outputs: data.outputs || {}, + }); + + } catch (error) { + // Log detailed error on server, return generic message to client + console.error('Error fetching execution status:', error); + return NextResponse.json( + { error: 'An unexpected error occurred. Please try again.' }, + { status: 500 } + ); + } +} \ No newline at end of file diff --git a/ui/app/configure/page.jsx b/ui/app/configure/page.jsx new file mode 100644 index 0000000..6503f95 --- /dev/null +++ b/ui/app/configure/page.jsx @@ -0,0 +1,28 @@ +"use client"; + +import Header from "@/components/Header"; +import Footer from "@/components/Footer"; +import ServiceConfigGenerator from "@/components/ServiceConfigGenerator"; +import styles from "./page.module.css"; + +export default function ConfigurePage() { + return ( + <> +

+
+
+
+

Configure Your Services

+

+ Manually specify your project's services, technologies, and infrastructure. + Download the configuration file and add it to your repository for the InFoundry pipeline to use. +

+
+ + +
+
+
+ + ); +} diff --git a/ui/app/configure/page.module.css b/ui/app/configure/page.module.css new file mode 100644 index 0000000..19dc600 --- /dev/null +++ b/ui/app/configure/page.module.css @@ -0,0 +1,48 @@ +.main { + min-height: 100vh; + padding-top: 80px; + padding-bottom: var(--spacing-3xl); + background: + radial-gradient(ellipse 80% 50% at 50% -20%, rgba(120, 119, 198, 0.15), transparent), + var(--color-bg-primary); +} + +.container { + width: 100%; + max-width: 1400px; + margin: 0 auto; + padding: var(--spacing-2xl) var(--spacing-lg); +} + +.hero { + text-align: center; + margin-bottom: var(--spacing-3xl); +} + +.title { + font-size: clamp(2rem, 4vw, 3rem); + color: var(--color-text-primary); + margin-bottom: var(--spacing-md); + background: linear-gradient(135deg, #ffffff 0%, #a1a1aa 100%); + -webkit-background-clip: text; + -webkit-text-fill-color: transparent; + background-clip: text; +} + +.description { + max-width: 700px; + margin: 0 auto; + font-size: 1.1rem; + color: var(--color-text-secondary); + line-height: 1.7; +} + +@media (max-width: 768px) { + .container { + padding: var(--spacing-xl) var(--spacing-md); + } + + .hero { + margin-bottom: var(--spacing-xl); + } +} diff --git a/ui/app/dashboard/page.jsx b/ui/app/dashboard/page.jsx index 8d58193..f33119e 100644 --- a/ui/app/dashboard/page.jsx +++ b/ui/app/dashboard/page.jsx @@ -1,6 +1,7 @@ "use client"; -import { useCallback, useState } from "react"; +import { useCallback, useState, useRef, useEffect } from "react"; +import Link from "next/link"; import { ReactFlow, Controls, @@ -9,6 +10,8 @@ import { useEdgesState, addEdge, Panel, + Handle, + Position, } from "@xyflow/react"; import "@xyflow/react/dist/style.css"; import { @@ -20,233 +23,428 @@ import { HardDrive, MessageSquare, Download, - Plus, - Save, Share2, + Upload, + Zap, + Box, + Grid, + Cpu, + Archive, + Bell, + Activity, + TrendingUp, + Folder, + X, + Info, + Shield, + Lock, + Key, + Gauge, + Container, + Plus, } from "lucide-react"; import styles from "./page.module.css"; -// Custom node types -const nodeTypes = { - service: ServiceNode, - database: DatabaseNode, - loadBalancer: LoadBalancerNode, - cache: CacheNode, - queue: QueueNode, +// Component palette items organized by category +const PALETTE_ITEMS = { + compute: [ + { type: "ec2", label: "Amazon EC2", icon: Server, color: "#FF9900" }, + { type: "ecs", label: "Amazon ECS", icon: Container, color: "#FF9900" }, + { type: "lambda", label: "AWS Lambda", icon: Zap, color: "#FF9900" }, + { type: "fargate", label: "AWS Fargate", icon: Box, color: "#FF9900" }, + ], + database: [ + { type: "rds", label: "Amazon RDS", icon: Database, color: "#3B48CC" }, + { type: "dynamodb", label: "DynamoDB", icon: Grid, color: "#3B48CC" }, + { type: "elasticache", label: "ElastiCache", icon: Cpu, color: "#C925D1" }, + { type: "aurora", label: "Aurora", icon: Database, color: "#3B48CC" }, + ], + network: [ + { type: "alb", label: "Load Balancer", icon: Share2, color: "#8C4FFF" }, + { type: "api_gateway", label: "API Gateway", icon: Globe, color: "#8C4FFF" }, + { type: "cloudfront", label: "CloudFront", icon: Cloud, color: "#1A73E8" }, + { type: "vpc", label: "Amazon VPC", icon: Shield, color: "#8C4FFF" }, + ], + storage: [ + { type: "s3", label: "Amazon S3", icon: Folder, color: "#3F8624" }, + { type: "efs", label: "Amazon EFS", icon: HardDrive, color: "#3F8624" }, + { type: "ecr", label: "Amazon ECR", icon: Archive, color: "#FF9900" }, + ], + messaging: [ + { type: "sqs", label: "Amazon SQS", icon: MessageSquare, color: "#FF4F8B" }, + { type: "sns", label: "Amazon SNS", icon: Bell, color: "#FF4F8B" }, + { type: "kinesis", label: "Kinesis", icon: Activity, color: "#FF4F8B" }, + ], + security: [ + { type: "iam", label: "AWS IAM", icon: Lock, color: "#DD344C" }, + { type: "cognito", label: "Cognito", icon: Key, color: "#DD344C" }, + { type: "cloudwatch", label: "CloudWatch", icon: Gauge, color: "#FF4F8B" }, + ], +}; + +// Full service name mapping +const SERVICE_NAME_MAP = { + rds: "Amazon RDS", + ec2: "Amazon EC2", + ecs: "Amazon ECS", + ecs_cluster: "Amazon ECS Cluster", + eks: "Amazon EKS", + lambda: "AWS Lambda", + s3: "Amazon S3", + dynamodb: "Amazon DynamoDB", + elasticache: "Amazon ElastiCache", + sqs: "Amazon SQS", + sns: "Amazon SNS", + alb: "Application Load Balancer", + nlb: "Network Load Balancer", + elb: "Elastic Load Balancer", + api_gateway: "Amazon API Gateway", + cloudfront: "Amazon CloudFront", + cdn: "Amazon CloudFront CDN", + route53: "Amazon Route 53", + vpc: "Amazon VPC", + iam: "AWS IAM", + cognito: "Amazon Cognito", + secrets_manager: "AWS Secrets Manager", + kms: "AWS KMS", + cloudwatch: "Amazon CloudWatch", + xray: "AWS X-Ray", + efs: "Amazon EFS", + ebs: "Amazon EBS", + ecr: "Amazon ECR", + fargate: "AWS Fargate", + aurora: "Amazon Aurora", + redshift: "Amazon Redshift", + kinesis: "Amazon Kinesis", + eventbridge: "Amazon EventBridge", + hpa: "Horizontal Pod Autoscaler", + kubernetes: "Kubernetes", +}; + +// AWS service color scheme +const SERVICE_COLORS = { + ec2: "#FF9900", ecs: "#FF9900", ecs_cluster: "#FF9900", lambda: "#FF9900", fargate: "#FF9900", + rds: "#3B48CC", aurora: "#3B48CC", dynamodb: "#3B48CC", + s3: "#3F8624", efs: "#3F8624", ebs: "#3F8624", + vpc: "#8C4FFF", alb: "#8C4FFF", nlb: "#8C4FFF", api_gateway: "#8C4FFF", + cloudfront: "#1A73E8", cdn: "#1A73E8", + elasticache: "#C925D1", + sqs: "#FF4F8B", sns: "#FF4F8B", kinesis: "#FF4F8B", + iam: "#DD344C", cognito: "#DD344C", + cloudwatch: "#FF4F8B", + ecr: "#FF9900", +}; + +// Icon mapping +const ICON_MAP = { + rds: Database, aurora: Database, dynamodb: Grid, database: Database, + ec2: Server, ecs: Container, ecs_cluster: Container, lambda: Zap, fargate: Box, + s3: Folder, efs: HardDrive, ebs: HardDrive, storage: HardDrive, + vpc: Shield, alb: Share2, nlb: Share2, api_gateway: Globe, + cloudfront: Cloud, cdn: Cloud, + elasticache: Cpu, + sqs: MessageSquare, sns: Bell, kinesis: Activity, + iam: Lock, cognito: Key, + cloudwatch: Gauge, + ecr: Archive, + server: Server, globe: Globe, "share-2": Share2, box: Box, + layers: Layers, zap: Zap, cloud: Cloud, folder: Folder, }; -// Initial nodes for demo -const initialNodes = [ - { - id: "lb", - type: "loadBalancer", - position: { x: 400, y: 50 }, - data: { label: "Load Balancer" }, - }, - { - id: "auth", - type: "service", - position: { x: 200, y: 200 }, - data: { label: "Auth Service" }, - }, - { - id: "api", - type: "service", - position: { x: 400, y: 200 }, - data: { label: "API Gateway" }, - }, - { - id: "payments", - type: "service", - position: { x: 600, y: 200 }, - data: { label: "Payments" }, - }, - { - id: "db", - type: "database", - position: { x: 300, y: 380 }, - data: { label: "PostgreSQL" }, - }, - { - id: "cache", - type: "cache", - position: { x: 500, y: 380 }, - data: { label: "Redis Cache" }, - }, -]; - -const initialEdges = [ - { id: "e1", source: "lb", target: "auth", animated: true }, - { id: "e2", source: "lb", target: "api", animated: true }, - { id: "e3", source: "lb", target: "payments", animated: true }, - { id: "e4", source: "auth", target: "db" }, - { id: "e5", source: "api", target: "db" }, - { id: "e6", source: "api", target: "cache" }, - { id: "e7", source: "payments", target: "db" }, -]; - -// Component palette items -const paletteItems = [ - { type: "service", icon: Server, label: "Service" }, - { type: "database", icon: Database, label: "Database" }, - { type: "loadBalancer", icon: Globe, label: "Load Balancer" }, - { type: "cache", icon: HardDrive, label: "Cache" }, - { type: "queue", icon: MessageSquare, label: "Queue" }, -]; +function getFullServiceName(label, type) { + const typeKey = type?.toLowerCase().replace(/[- ]/g, "_"); + if (SERVICE_NAME_MAP[typeKey]) return SERVICE_NAME_MAP[typeKey]; + const labelKey = label?.toLowerCase().replace(/[- ]/g, "_"); + if (SERVICE_NAME_MAP[labelKey]) return SERVICE_NAME_MAP[labelKey]; + return label || "Service"; +} + +function getServiceColor(type, defaultColor) { + const typeKey = type?.toLowerCase().replace(/[- ]/g, "_"); + return SERVICE_COLORS[typeKey] || defaultColor || "#666"; +} + +function getIconComponent(icon, type) { + const typeKey = type?.toLowerCase().replace(/[- ]/g, "_"); + return ICON_MAP[typeKey] || ICON_MAP[icon] || Box; +} + +// InFoundry Logo +function InFoundryLogo() { + return ( + + + + + ); +} + +// Infrastructure node component +function InfrastructureNode({ data }) { + const IconComponent = getIconComponent(data.icon, data.type); + const bgColor = getServiceColor(data.type, data.style?.background); + const fullName = getFullServiceName(data.label, data.type); + + return ( +
+ +
+
+ +
+ {fullName} + {data.scaling && } +
+ +
+ ); +} + +const nodeTypes = { infrastructureNode: InfrastructureNode }; +const initialNodes = []; +const initialEdges = []; export default function DashboardPage() { const [nodes, setNodes, onNodesChange] = useNodesState(initialNodes); const [edges, setEdges, onEdgesChange] = useEdgesState(initialEdges); + const [metadata, setMetadata] = useState(null); + const [showMetadata, setShowMetadata] = useState(false); const [selectedPaletteItem, setSelectedPaletteItem] = useState(null); + const [showPalette, setShowPalette] = useState(true); + const fileInputRef = useRef(null); const onConnect = useCallback( (params) => setEdges((eds) => addEdge({ ...params, animated: true }, eds)), [setEdges] ); - const onPaneClick = useCallback( - (event) => { - if (!selectedPaletteItem) return; + // Load graph from localStorage if coming from pipeline + useEffect(() => { + const savedGraph = localStorage.getItem('infoundry_graph'); + if (savedGraph) { + try { + const graphData = JSON.parse(savedGraph); + + // Map nodes + const mappedNodes = (graphData.nodes || []).map((node) => ({ + id: node.id, + type: node.type || "infrastructureNode", + position: node.position || { x: 0, y: 0 }, + data: { ...node.data, icon: node.data?.icon || "box", type: node.data?.type || node.id, style: node.style }, + })); + + // Map edges + const mappedEdges = (graphData.edges || []).map((edge) => ({ + id: edge.id, source: edge.source, target: edge.target, + type: edge.type || "smoothstep", animated: edge.animated || false, style: edge.style || {}, + })); + + setNodes(mappedNodes); + setEdges(mappedEdges); + setMetadata(graphData.metadata || null); + setShowMetadata(true); + + // Clear localStorage after loading + localStorage.removeItem('infoundry_graph'); + } catch (err) { + console.error("Failed to load graph from localStorage:", err); + } + } + }, [setNodes, setEdges]); + + // Add node on canvas click when palette item is selected + const onPaneClick = useCallback((event) => { + if (!selectedPaletteItem) return; - const reactFlowBounds = event.target.getBoundingClientRect(); - const position = { - x: event.clientX - reactFlowBounds.left - 75, - y: event.clientY - reactFlowBounds.top - 30, - }; + const bounds = event.target.getBoundingClientRect(); + const position = { + x: event.clientX - bounds.left - 70, + y: event.clientY - bounds.top - 40, + }; - const newNode = { - id: `${selectedPaletteItem.type}-${Date.now()}`, + const newNode = { + id: `${selectedPaletteItem.type}-${Date.now()}`, + type: "infrastructureNode", + position, + data: { + label: selectedPaletteItem.label, type: selectedPaletteItem.type, - position, - data: { label: `New ${selectedPaletteItem.label}` }, - }; - - setNodes((nds) => [...nds, newNode]); - setSelectedPaletteItem(null); - }, - [selectedPaletteItem, setNodes] - ); + icon: selectedPaletteItem.type, + }, + }; + + setNodes((nds) => [...nds, newNode]); + setSelectedPaletteItem(null); + }, [selectedPaletteItem, setNodes]); + + // Import graph + const handleImportGraph = useCallback((event) => { + const file = event.target.files?.[0]; + if (!file) return; - const handleExportIaC = () => { - // Generate graph JSON for export - const graphData = { nodes, edges }; - console.log("Exporting IaC:", JSON.stringify(graphData, null, 2)); - alert("IaC export initiated! Check console for graph data."); + const reader = new FileReader(); + reader.onload = (e) => { + try { + const graphData = JSON.parse(e.target.result); + const mappedNodes = (graphData.nodes || []).map((node) => ({ + id: node.id, + type: node.type || "infrastructureNode", + position: node.position || { x: 0, y: 0 }, + data: { ...node.data, icon: node.data?.icon || "box", type: node.data?.type || node.id, style: node.style }, + })); + const mappedEdges = (graphData.edges || []).map((edge) => ({ + id: edge.id, source: edge.source, target: edge.target, + type: edge.type || "smoothstep", animated: edge.animated || false, style: edge.style || {}, + })); + setNodes(mappedNodes); + setEdges(mappedEdges); + setMetadata(graphData.metadata || null); + setShowMetadata(true); + } catch (err) { + alert("Invalid graph.json file."); + } + }; + reader.readAsText(file); + event.target.value = ""; + }, [setNodes, setEdges]); + + const handleExportGraph = () => { + const graphData = { nodes: nodes.map(n => ({ id: n.id, type: n.type, position: n.position, data: n.data })), edges: edges.map(e => ({ id: e.id, source: e.source, target: e.target })), metadata }; + const blob = new Blob([JSON.stringify(graphData, null, 2)], { type: "application/json" }); + const url = URL.createObjectURL(blob); + const a = document.createElement("a"); + a.href = url; + a.download = "architecture-graph.json"; + a.click(); + URL.revokeObjectURL(url); + }; + + const handleClearCanvas = () => { + setNodes([]); + setEdges([]); + setMetadata(null); }; + const hasGraph = nodes.length > 0; + return (
- {/* Sidebar */} - - - {/* Main Canvas */} -
- - - - - {/* Top Toolbar */} - - - - - - - {/* Selection Indicator */} - {selectedPaletteItem && ( - - - Click on canvas to add {selectedPaletteItem.label} - +
+ + + + {hasGraph && ( + <> + + + )} - -
-
- ); -} + +
-// Custom Node Components -function ServiceNode({ data }) { - return ( -
- - {data.label} -
- ); -} +
+ {/* Component Palette Sidebar */} + {showPalette && ( + + )} -function DatabaseNode({ data }) { - return ( -
- - {data.label} -
- ); -} + {/* Main Canvas */} +
+ + + -function LoadBalancerNode({ data }) { - return ( -
- - {data.label} -
- ); -} + {/* Selection Indicator */} + {selectedPaletteItem && ( + + + Click on canvas to place {selectedPaletteItem.label} + + )} -function CacheNode({ data }) { - return ( -
- - {data.label} -
- ); -} + {/* Metadata Panel */} + {metadata && showMetadata && ( + +
+

Architecture Info

+ +
+
+
Pattern{metadata.pattern || "N/A"}
+
Source{metadata.source || "N/A"}
+
Cloud{metadata.cloud_provider?.toUpperCase() || "N/A"}
+
Components{metadata.component_count || nodes.length}
+
+ + )} -function QueueNode({ data }) { - return ( -
- - {data.label} + {metadata && !showMetadata && ( + + + + )} + +
+
); } diff --git a/ui/app/dashboard/page.module.css b/ui/app/dashboard/page.module.css index cc969c2..53f86f9 100644 --- a/ui/app/dashboard/page.module.css +++ b/ui/app/dashboard/page.module.css @@ -1,75 +1,210 @@ .dashboard { display: flex; + flex-direction: column; height: 100vh; background-color: var(--color-bg-primary); } -/* ===== Sidebar ===== */ +/* ===== Header ===== */ +.header { + display: flex; + justify-content: space-between; + align-items: center; + padding: var(--spacing-sm) var(--spacing-lg); + background-color: var(--color-bg-secondary); + border-bottom: 1px solid var(--color-border); + flex-shrink: 0; +} + +.headerLeft { + display: flex; + align-items: center; + gap: var(--spacing-lg); +} + +.logo { + display: flex; + align-items: center; + gap: var(--spacing-sm); + color: var(--color-text-primary); + transition: opacity var(--transition-fast); +} + +.logo:hover { + opacity: 0.8; +} + +.logoText { + font-size: 1rem; + font-weight: 600; + letter-spacing: -0.02em; +} + +.headerDivider { + width: 1px; + height: 20px; + background-color: var(--color-border); +} + +.headerTitle { + font-family: var(--font-sans); + font-size: 0.875rem; + font-weight: 500; + color: var(--color-text-secondary); +} + +.headerActions { + display: flex; + gap: var(--spacing-sm); +} + +.actionBtn, +.actionBtnDanger { + display: flex; + align-items: center; + gap: var(--spacing-xs); + padding: var(--spacing-xs) var(--spacing-md); + font-family: var(--font-sans); + font-size: 0.75rem; + font-weight: 500; + border-radius: var(--radius-md); + cursor: pointer; + transition: all var(--transition-fast); +} + +.actionBtn { + color: var(--color-text-secondary); + background-color: transparent; + border: 1px solid var(--color-border); +} + +.actionBtn:hover { + color: var(--color-text-primary); + border-color: var(--color-text-muted); + background-color: var(--color-bg-tertiary); +} + +.actionBtnDanger { + color: #ef4444; + background-color: transparent; + border: 1px solid rgba(239, 68, 68, 0.3); +} + +.actionBtnDanger:hover { + background-color: rgba(239, 68, 68, 0.1); + border-color: #ef4444; +} + +/* ===== Content Layout ===== */ +.content { + display: flex; + flex: 1; + overflow: hidden; +} + +/* ===== Sidebar Palette ===== */ .sidebar { - width: 240px; + width: 220px; background-color: var(--color-bg-secondary); border-right: 1px solid var(--color-border); display: flex; flex-direction: column; + overflow-y: auto; + flex-shrink: 0; } .sidebarHeader { - padding: var(--spacing-lg); + padding: var(--spacing-md); border-bottom: 1px solid var(--color-border); } -.sidebarTitle { +.sidebarHeader h2 { font-family: var(--font-sans); - font-size: 0.875rem; + font-size: 0.75rem; font-weight: 600; text-transform: uppercase; letter-spacing: 0.1em; color: var(--color-text-primary); + margin-bottom: var(--spacing-xs); } -.palette { - padding: var(--spacing-md); +.sidebarHint { + font-size: 0.65rem; + color: var(--color-text-muted); +} + +.paletteList { + padding: var(--spacing-sm); + display: flex; + flex-direction: column; + gap: var(--spacing-md); +} + +.paletteCategory { display: flex; flex-direction: column; gap: var(--spacing-xs); - flex: 1; +} + +.categoryTitle { + font-family: var(--font-sans); + font-size: 0.65rem; + font-weight: 600; + text-transform: uppercase; + letter-spacing: 0.08em; + color: var(--color-text-muted); + padding: 0 var(--spacing-xs); +} + +.paletteItems { + display: flex; + flex-direction: column; + gap: 2px; } .paletteItem { display: flex; align-items: center; gap: var(--spacing-sm); - padding: var(--spacing-sm) var(--spacing-md); + padding: var(--spacing-xs) var(--spacing-sm); font-family: var(--font-sans); - font-size: 0.875rem; + font-size: 0.75rem; color: var(--color-text-secondary); background-color: transparent; border: 1px solid transparent; - border-radius: var(--radius-md); + border-radius: var(--radius-sm); cursor: pointer; transition: all var(--transition-fast); + text-align: left; } .paletteItem:hover { color: var(--color-text-primary); background-color: var(--color-bg-tertiary); + border-color: var(--color-border); } .paletteItem.selected { color: var(--color-text-primary); background-color: var(--color-bg-tertiary); - border-color: var(--color-accent); + border-color: var(--item-color, var(--color-accent)); + box-shadow: 0 0 10px color-mix(in srgb, var(--item-color, var(--color-accent)) 30%, transparent); } -.sidebarInfo { - padding: var(--spacing-md); - border-top: 1px solid var(--color-border); +.paletteItemIcon { + width: 24px; + height: 24px; + display: flex; + align-items: center; + justify-content: center; + border-radius: var(--radius-sm); + flex-shrink: 0; } -.sidebarInfo p { - font-size: 0.75rem; - color: var(--color-text-muted); - line-height: 1.5; +.paletteItemLabel { + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; } /* ===== Canvas ===== */ @@ -82,7 +217,6 @@ background-color: var(--color-bg-primary) !important; } -/* React Flow overrides for dark mode */ .reactFlow :global(.react-flow__node) { background: transparent; border: none; @@ -98,18 +232,17 @@ stroke: var(--color-accent); } -.reactFlow :global(.react-flow__handle) { - width: 8px; - height: 8px; - background-color: var(--color-text-muted); - border: 2px solid var(--color-bg-primary); +.handle { + width: 8px !important; + height: 8px !important; + background-color: var(--color-text-muted) !important; + border: 2px solid var(--color-bg-primary) !important; } -.reactFlow :global(.react-flow__handle:hover) { - background-color: var(--color-accent); +.handle:hover { + background-color: var(--color-accent) !important; } -/* Controls styling */ .controls { background-color: var(--color-bg-secondary) !important; border: 1px solid var(--color-border) !important; @@ -130,109 +263,198 @@ fill: var(--color-text-secondary) !important; } -/* ===== Toolbar ===== */ -.toolbar { +/* ===== Selection Indicator ===== */ +.selectionIndicator { display: flex; + align-items: center; gap: var(--spacing-sm); - padding: var(--spacing-sm); + padding: var(--spacing-sm) var(--spacing-md); + font-size: 0.8rem; + font-weight: 500; + color: var(--color-bg-primary); + background: linear-gradient(135deg, #ffffff 0%, #e0e0e0 100%); + border-radius: var(--radius-full); + box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3); +} + +/* ===== Nodes ===== */ +.infraNode { + display: flex; + flex-direction: column; + align-items: center; + padding: var(--spacing-md); + min-width: 140px; + background-color: var(--color-bg-card); + border: 2px solid; + border-radius: var(--radius-lg); + cursor: grab; + transition: all var(--transition-fast); +} + +.infraNode:hover { + transform: translateY(-2px); +} + +.infraNodeContent { + display: flex; + flex-direction: column; + align-items: center; + gap: var(--spacing-xs); + position: relative; +} + +.infraNodeIcon { + width: 40px; + height: 40px; + display: flex; + align-items: center; + justify-content: center; + border-radius: var(--radius-md); +} + +.infraNodeLabel { + font-family: var(--font-sans); + font-size: 0.7rem; + font-weight: 600; + color: var(--color-text-primary); + text-align: center; + max-width: 120px; +} + +.scalingBadge { + position: absolute; + top: -8px; + right: -8px; + width: 20px; + height: 20px; + display: flex; + align-items: center; + justify-content: center; + background: linear-gradient(135deg, #22c55e 0%, #16a34a 100%); + border-radius: 50%; + color: white; +} + +/* ===== Metadata Panel ===== */ +.metadataPanel { background-color: var(--color-bg-secondary); border: 1px solid var(--color-border); border-radius: var(--radius-md); + min-width: 240px; + max-width: 280px; } -.toolbarBtn { +.metadataHeader { display: flex; align-items: center; - gap: var(--spacing-xs); + justify-content: space-between; padding: var(--spacing-sm) var(--spacing-md); + border-bottom: 1px solid var(--color-border); +} + +.metadataHeader h3 { font-family: var(--font-sans); font-size: 0.75rem; - font-weight: 500; - text-transform: uppercase; - letter-spacing: 0.05em; - color: var(--color-text-secondary); - background-color: transparent; - border: 1px solid var(--color-border); - border-radius: var(--radius-sm); + font-weight: 600; + color: var(--color-text-primary); +} + +.closeBtn { + display: flex; + align-items: center; + justify-content: center; + padding: var(--spacing-xs); + background: transparent; + border: none; + color: var(--color-text-muted); cursor: pointer; + border-radius: var(--radius-sm); transition: all var(--transition-fast); } -.toolbarBtn:hover { +.closeBtn:hover { color: var(--color-text-primary); - border-color: var(--color-text-muted); background-color: var(--color-bg-tertiary); } -/* Selection Indicator */ -.selectionIndicator { +.metadataContent { + padding: var(--spacing-sm) var(--spacing-md); + display: flex; + flex-direction: column; + gap: var(--spacing-xs); +} + +.metadataItem { display: flex; + justify-content: space-between; align-items: center; - gap: var(--spacing-sm); - padding: var(--spacing-sm) var(--spacing-md); - font-size: 0.875rem; - color: var(--color-text-primary); - background-color: var(--color-accent); - border-radius: var(--radius-full); + font-size: 0.75rem; } -.selectionIndicator span { - color: var(--color-bg-primary); +.metadataLabel { + color: var(--color-text-muted); + text-transform: uppercase; + letter-spacing: 0.05em; } -.selectionIndicator svg { - color: var(--color-bg-primary); +.metadataValue { + font-weight: 500; + color: var(--color-text-primary); } -/* ===== Custom Nodes ===== */ -.node { - display: flex; - align-items: center; - gap: var(--spacing-sm); - padding: var(--spacing-sm) var(--spacing-md); - min-width: 150px; - background-color: var(--color-bg-card); - border: 2px solid var(--color-border); - border-radius: var(--radius-md); - cursor: grab; - transition: all var(--transition-fast); +.sourceBadge { + padding: 2px 6px; + background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 100%); + border-radius: var(--radius-full); + font-size: 0.65rem; } -.node:hover { - box-shadow: var(--shadow-md); +.metadataToggle { + background-color: var(--color-bg-secondary) !important; + border: 1px solid var(--color-border) !important; + border-radius: var(--radius-md) !important; + padding: 0 !important; } -.nodeIcon { +.metadataToggle button { + display: flex; + align-items: center; + gap: var(--spacing-xs); + padding: var(--spacing-xs) var(--spacing-sm); + font-size: 0.7rem; color: var(--color-text-secondary); - flex-shrink: 0; + background: transparent; + border: none; + cursor: pointer; } -.nodeLabel { - font-family: var(--font-sans); - font-size: 0.875rem; - font-weight: 500; +.metadataToggle button:hover { color: var(--color-text-primary); - white-space: nowrap; } /* ===== Responsive ===== */ @media (max-width: 768px) { .sidebar { - width: 60px; + width: 180px; } - .sidebarTitle, - .paletteItem span, - .sidebarInfo { - display: none; + .header { + flex-wrap: wrap; + gap: var(--spacing-sm); + } + + .headerActions { + flex-wrap: wrap; } - .paletteItem { - justify-content: center; - padding: var(--spacing-md); + .actionBtn span, + .actionBtnDanger span { + display: none; } +} - .toolbarBtn span { +@media (max-width: 480px) { + .sidebar { display: none; } } diff --git a/ui/app/layout.jsx b/ui/app/layout.jsx index 9baa4f9..d294e4b 100644 --- a/ui/app/layout.jsx +++ b/ui/app/layout.jsx @@ -8,7 +8,7 @@ export const metadata = { export default function RootLayout({ children }) { return ( - + @@ -17,7 +17,7 @@ export default function RootLayout({ children }) { rel="stylesheet" /> - + {children} diff --git a/ui/app/page.jsx b/ui/app/page.jsx index 6a22386..80e7a7a 100644 --- a/ui/app/page.jsx +++ b/ui/app/page.jsx @@ -1,14 +1,12 @@ "use client"; -import { useState } from "react"; import Link from "next/link"; -import { ArrowRight, Paperclip, Send, Info } from "lucide-react"; +import { ArrowRight, Zap } from "lucide-react"; import Header from "@/components/Header"; import Footer from "@/components/Footer"; import styles from "./page.module.css"; export default function Home() { - const [prompt, setPrompt] = useState(""); const useCases = [ "Cloud Migration", @@ -50,30 +48,6 @@ export default function Home() { infrastructure β€” from repos to production β€” with a single prompt.

- {/* Prompt Input */} -
-