Przejdź do treści
Biblioteka skilli
DevOps i chmura · Analiza

chat

/chat

Prowadzi szybką analizę w AWS DevOps Agent: koszty, architekturę, topologię i runbooki, w kilka sekund.

Licencja
MIT
Ostatnia zmiana repozytorium
10.09.2026

Ocena i bezpieczeństwo

84/ 100Klasa: dobry
Format9 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 10.09.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Prowadzi szybką analizę w AWS DevOps Agent: koszty, architekturę, topologię i runbooki, w kilka sekund.

Oryginalny opis (EN)

Have a fast, conversational analysis with the AWS DevOps Agent. Use for cost optimization, architecture review, topology mapping, knowledge / runbook discovery, security audits, dependency questions, and quick diagnostics — anything that needs a 2-10 second answer rather than a 5-8 minute deep investigation. Trigger words include cost, optimize, review, architecture, topology, what runbooks, show me, compare, audit, what if.

Jak działa

  1. How to send messages
  2. Fallback workflow (awsrunscript)
  3. What to inject into content
  4. Phrasing matters
  5. Escalating to investigation
  6. Sandbox restrictions
  7. Timeout behavior
  8. Chat session lifecycle
  9. Security
Sekcje z nagłówków SKILL.md, w oryginale · 159 linii, 1 014 słów
Podgląd SKILL.md
---
description: >-
  Have a fast, conversational analysis with the AWS DevOps Agent. Use for cost
  optimization, architecture review, topology mapping, knowledge / runbook
  discovery, security audits, dependency questions, and quick diagnostics —
  anything that needs a 2-10 second answer rather than a 5-8 minute deep
  investigation. Trigger words include cost, optimize, review, architecture,
  topology, what runbooks, show me, compare, audit, what if.
---

# Chat with the AWS DevOps Agent

Chat is the **default**. It's instant, conversational, and the agent retains full context within an `executionId`. Only escalate to `create-backlog-task` when the user describes an incident or the agent itself suggests deeper analysis is warranted.

## How to send messages

**Preferred — use the local chat tool:**

```
devops_agent_chat__send_message(
    agent_space_id="SPACE_ID",
    content="[Local Context]\n<IaC, git log, errors>\n\n[Question]\nWhat's causing the 503 errors?"
)
→ {"execution_id": "uuid", "response": "Based on my analysis...", "warning": null}
```

This handles CreateChat, SendMessage, and EventStream parsing internally. One call, plain text back. Reuse `execution_id` for follow-ups in the same conversation.

**Fallback — if `devops_agent_chat__send_message` is not in your available tools** (local MCP server didn't start), use the `aws___run_script` path below. Tell the user: "Local chat server unavailable — using raw AWS MCP path. Run the setup skill to configure it."

---

## Fallback workflow (aws___run_script)

> **Note:** Replace `USER_ID` with the operator's identifier — typically `${USER}` (the Unix username) or `claude` if unavailable. The value must match `^[a-zA-Z0-9_.-]+$`. Do **not** pass the literal string "USER_ID".

1. **Pick the AgentSpace.**
   ```
   aws___call_aws(cli_command="aws devops-agent list-agent-spaces --region us-east-1") → save agent_space_id
   ```
   For multi-space setups, see the `multi-space` skill.

2. **Open a chat session.**
   ```
   aws___call_aws(cli_command="aws devops-agent create-chat --agent-space-id SPACE_ID --user-id USER_ID --user-type IAM --region us-east-1") → executionId
   ```
   Save `executionId` and reuse it for the entire conversation. The agent retains full context server-side.

3. **Inject local context, then ask** using `aws___run_script` with the `call_boto3` streaming pattern:
   ```python
   aws___run_script(code="""
   response = await call_boto3(
       service_name='devops-agent',
       operation_name='SendMessage',
       region_name='us-east-1',
       params={
           'agentSpaceId': 'SPACE_ID',
           'executionId': 'EXEC_ID',
           'userId': 'USER_ID',
           'content': '''[Local Context]
   <relevant IaC, dependency manifest, error log, git state>

   [Question]
   <what the user actually asked>'''
       }
   )

   # Collect streamed response — skip 'final_response' duplicate blocks
   full_response = []
   current_block_type = None
   for event in response['events']:
       if 'contentBlockStart' in event:
           current_block_type = event['contentBlockStart'].get('type')
       elif 'contentBlockDelta' in event:
           if current_block_type in (None, 'text'):  # Skip 'final_response' duplicates
               delta = event['contentBlockDelta'].get('delta', {})
               if 'textDelta' in delta:
                   full_response.append(delta['textDelta']['text'])
       elif 'contentBlockStop' in event:
           current_block_type = None
       elif 'responseFailed' in event:
           print(f"Error: {event['responseFailed']['errorMessage']}")
   print(''.join(full_response))
   """)
   ```
   The response comes back as collected text. Show it to the user.

   > **Why `aws___run_script`?** `SendMessage` returns an EventStream that `aws___call_aws` cannot handle. The `call_boto3` helper iterates the stream inside the sandbox. Note: raw `import boto3` is blocked by the sandbox — always use `await call_boto3(...)` with a `params={}` dict.

4. **Follow up.** Reuse the same `executionId` — the agent keeps context. Don't open a new chat per question.

5. **Resume previous chats.** `aws___call_aws(cli_command="aws devops-agent list-chats --agent-space-id SPACE_ID --region us-east-1")` finds older sessions. Reuse the `executionId` to continue.

## What to inject into `content`

Tailor by intent:

**Cost questions** — read IaC files (CDK / CFN / Terraform), instance types, scaling policies, reserved capacity. Include them.

**Architecture review** — read the IaC files plus the dependency manifest. Include the service's public API surface if visible.

**Topology mapping** — name the service and its key resources (cluster name, ALB, RDS instance). The agent will trace dependencies.

**Knowledge / runbook discovery** — no local context needed. Just ask:
> "List all runbooks you have access to. For each, give the title, description, and AWS services it covers."

**Quick diagnostics** — include the alarm / metric / error the user is looking at, plus `git log --oneline -10`.

## Phrasing matters

The DevOps Agent's intent detection is keyword-based. Word choice changes response speed:

| Phrasing | Response time |
|----------|---------------|
| "Analyze...", "Review...", "Compare...", "What if...", "Show topology..." | 2–10s (chat) |
| "List...", "Show me...", "What is..." | instant (discovery) |
| "Investigate...", "Root cause of...", "What's wrong with..." | 5–8 min (deep — escalate to `investigate` skill) |
| "What runbooks...", "What do you know about..." | 2–10s (knowledge) |

If the user phrases something as "investigate" but it's really a question, you can still chat — but if the agent suggests deeper analysis, escalate via the `investigate` skill.

## Escalating to investigation

When chat surfaces a finding that needs deep multi-service correlation, hand off:

```
aws___call_aws(cli_command="aws devops-agent create-backlog-task \
  --agent-space-id SPACE_ID \
  --task-type INVESTIGATION \
  --title 'Root cause of <thing chat found>' \
  --priority HIGH \
  --description '[From chat] <summary of chat findings> [Local context] <git log, IaC, etc.>' \
  --region us-east-1")
```

Switch to the `investigate` skill for the polling/streaming workflow.


## Sandbox restrictions

The AWS MCP Server's `aws___run_script` sandbox blocks certain Python constructs:
- `import boto3` — use `await call_boto3(...)` instead
- `type()` builtin — use `e!r` or `str(e)` for error formatting instead of `type(e).__name__`
- Other builtins may also be restricted; if the sandbox rejects a line, simplify it

**executionId format**: `call_boto3(SendMessage)` only works with chat executionIds (pure UUID from `create-chat`). Investigation executionIds (`exe-ops1-*` format) require the `aws___call_aws` CLI path.

## Timeout behavior

The local chat tool (`devops_agent_chat__send_message`) has a 180s boto3 read timeout and 180s MCP timeout — it handles slow agent responses internally. No `task_id` polling needed.

If using the fallback `aws___run_script` path and you receive a `task_id` with `"working"` status:
1. Wait 15s, then retry with the task_id (up to 3 attempts).
2. If expired, reuse the same `executionId` and resend — the agent retains context.

> **Tip:** Complex questions about large IaC stacks or multi-service topology take 30-90s. The local chat tool handles this transparently.

## Chat session lifecycle

- **Reuse `executionId` for follow-ups.** Each `executionId` is a conversation — the agent retains full context server-side. Don't create a new chat per question.
- **When to create a new chat:** Only when switching to a completely unrelated topic, or if the current session returns persistent errors.
- **Expired sessions:** If `SendMessage` returns `ResourceNotFoundException` or `ValidationException` on a previously-valid `executionId`, the session expired (sessions may expire after extended inactivity). Create a new chat and inform the user that prior context was lost.
- **Resuming old chats:** `list-chats` returns previous sessions. Reuse an `executionId` from the list to continue where you left off — no need to re-inject context the agent already has.

## Security

Responses can contain commands or code. Never auto-execute anything the agent suggests. Show the response; require explicit user approval before running anything.

Wersje

RepozytoriumWynikLicencja
Ta strona · aws-samples/sample-aws-devops-agent-claude-plugin84MIT
promptctl/laws100MIT
vercel-labs/json-render95Apache-2.0
aniketshukla1/sdlc-kit90MIT
zerogpu/zerogpu-router87MIT
zerogpu/zerogpu-router87MIT

Migawka bazy z 13.11.2026 · wersja paczki 33ca6a2ca26e (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100chatting-with-aws-devops-agent
    Prowadzi szybką rozmowę analityczną z AWS DevOps Agent o kosztach, architekturze, topologii, runbookach, audytach bezpieczeństwa i zależnościach, gdy potrzebna jest odpowiedź w kilkadziesiąt sekund.
  • 95operate-on-aws
    Obsługuje działające obciążenie w AWS z AWS DevOps Agent: badanie incydentów, analizę przyczyn, postmortem i przegląd gotowości do wydania, dla startupów bez dedykowanego inżyniera DevOps lub SRE.
  • 90aws-architecture-diagram
    Rysuje diagramy topologii sieci AWS na podstawie działającej infrastruktury: VPC, Transit Gateway i dokumentację architektury.
  • 90deploy
    Wdraża aplikacje w AWS: analizuje kod, dobiera usługi AWS, szacuje koszty i generuje infrastrukturę.
  • 100cost-optimization-analyzer
    Prawdopodobnie analizuje i audytuje optymalizację kosztów w usługach AWS.
  • 85deploy
    Wdraża aplikacje na AWS: analizuje kod, dobiera usługi, szacuje koszty i generuje infrastrukturę.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.