# Competenze
Le [Agent Skills](https://strandsagents.com/docs/user-guide/concepts/plugins/skills/) sono pacchetti di markdown e script che forniscono all'agente la conoscenza del dominio su richiesta. Ogni skill segue lo [AgentSkills.io](https://agentskills.io/specification)standard aperto: un `SKILL.md` file con frontespizio YAML (nome, descrizione) e istruzioni di markdown, oltre a cartelle opzionali. `scripts/` `references/` `assets/`
Le competenze utilizzano la divulgazione progressiva: i metadati vengono inseriti in anticipo nel prompt di sistema (circa 100 token) e le istruzioni complete vengono caricate su richiesta tramite una chiamata allo strumento. In questo modo si evita di inondare la finestra contestuale con istruzioni che l'agente potrebbe non aver bisogno.
L'imbracatura supporta quattro fonti di abilità:
| Origine | Description | Quando utilizzarlo |
| --- | --- | --- |
| ** AWS Competenze** | Pre-built competenze per AWS i servizi dell'[AWS Agent Toolkit](https://github.com/aws/agent-toolkit-for-aws/tree/main/skills). Abilita con modelli a globo. | Desideri AWS competenze già pronte all'uso con zero configurazioni. |
| **Git (HTTPS)** | Clona una skill da qualsiasi repository Git pubblico o privato. Supporta le sottodirectory. | Vuoi fare riferimento alle competenze di GitHub o qualsiasi host git senza caricarle su S3. GitLab |
| **Amazon S3** | Recupera una skill da un bucket S3 di proprietà del cliente utilizzando il ruolo di esecuzione. | Desideri il pieno controllo sul controllo delle versioni, sulla crittografia e sulla governance degli accessi. |
| **Path (file system)** | Fai riferimento a un'abilità già presente sul filesystem harness (inserita nell'immagine del contenitore o installata tramite). `InvokeAgentRuntimeCommand` | La skill fa parte dell'immagine del contenitore o è stata installata all'inizio della sessione. |
Le abilità vengono recuperate una volta per sessione alla prima chiamata. All'interno di una sessione, le abilità rimangono su disco durante più chiamate. Quando la macchina virtuale scade e inizia una nuova sessione, le competenze vengono recuperate nuovamente per garantire la freschezza.
È possibile impostarlo `skills` come predefinito sul cablaggio (tramite `CreateHarness` o`UpdateHarness`) o eseguire l'override per ogni chiamata. Invoke-time le abilità vengono aggiunte dopo le abilità in fase di creazione; se entrambe definiscono un'abilità con lo stesso nome, vince la versione in fase di invocazione.
**Nota**
****Per aggiungere un'abilità a un'imbracatura in modo interattivo, corri `agentcore` ad aprire il TUI, seleziona **aggiungi**, scegli **Harness**, passa alle Impostazioni avanzate e abilita le Competenze.**** Il wizard richiede quindi la fonte dell'abilità. Consulta la scheda **Interattiva** in [Git](#harness-skills-git) e [Amazon S3](#harness-skills-s3) di seguito per i passaggi relativi ai singoli sorgenti.
## AWS Competenze
AWS le competenze sono competenze predefinite che consentono agli agenti di interagire con i servizi. AWS Sono organizzate gerarchicamente e selezionate tramite schemi globulari. Visualizza la loro fonte su. [GitHub](https://github.com/aws/agent-toolkit-for-aws/tree/main/skills)
| Categoria | Pattern | Competenze tipiche |
| --- | --- | --- |
| Competenze fondamentali | `core-skills/*` | Operazioni EC2, S3, Lambda, DynamoDB e IAM. CloudWatch |
| Competenze di analisi | `specialized-skills/analytics-skills/*` | Athena, Glue QuickSight, operazioni sui data lake. |
| Competenze operative | `specialized-skills/operations-skills/*` | Risoluzione dei problemi, diagnostica, analisi dei registri. |
| Capacità di archiviazione | `specialized-skills/storage-skills/*` | S3, EFS, FSx, operazioni di backup. |
### Abilita tutto AWS abilità
**Example**
```
aws bedrock-agentcore-control create-harness \
--harness-name "MyHarness" \
--execution-role-arn "${ROLE_ARN}" \
--skills '[{"awsSkills": {}}]'
```
O al momento della chiamata:
```
response = client.invoke_harness(
harnessArn=HARNESS_ARN,
runtimeSessionId=SESSION_ID,
skills=[{"awsSkills": {}}],
messages=[{"role": "user", "content": [{"text": "List my EC2 instances and their status."}]}],
)
```
### Abilita le competenze per categoria
Usa i modelli globalizzati per abilitare categorie di abilità specifiche:
**Example**
```
aws bedrock-agentcore-control create-harness \
--harness-name "MyHarness" \
--execution-role-arn "${ROLE_ARN}" \
--skills '[{"awsSkills": {"paths": ["core-skills/*", "specialized-skills/operations-skills/*"]}}]'
```
### Abilita una singola abilità specifica
```
response = client.invoke_harness(
harnessArn=HARNESS_ARN,
runtimeSessionId=SESSION_ID,
skills=[{"awsSkills": {"paths": ["core-skills/aws-cdk"]}}],
messages=[{"role": "user", "content": [{"text": "Create a CDK stack for a Lambda function."}]}],
)
```
### Combina più modelli
```
skills=[{"awsSkills": {"paths": ["core-skills/aws-cdk", "core-skills/aws-serverless", "specialized-skills/storage-skills/*"]}}]
```
**Nota**
I percorsi devono essere relativi (senza `/` o`..`). I percorsi assoluti e l'attraversamento dei percorsi vengono rifiutati.
Se uno schema a globo non corrisponde a nessuna abilità, l'invocazione fallisce con un errore descrittivo.
Vengono unite più `awsSkills` voci nello stesso payload.
## Competenze Git (HTTPS)
Clona una skill da qualsiasi repository Git pubblico o privato. Supporta le sottodirectory all'interno di monorepos utilizzando sparse checkout.
**Example**
Archivio pubblico:
```
response = client.invoke_harness(
harnessArn=HARNESS_ARN,
runtimeSessionId=SESSION_ID,
skills=[
{"git": {"url": "https://github.com/anthropics/skills", "path": "skills/docx"}},
],
messages=[{"role": "user", "content": [{"text": "Summarize the attached DOCX file."}]}],
)
```
Archivio privato (richiede un token di accesso personale archiviato in [AgentCore Identity](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/identity.html)):
```
skills=[
{
"git": {
"url": "https://github.com/my-org/internal-skills",
"path": "excel",
"auth": {
"credentialArn": "arn:aws:bedrock-agentcore:us-west-2:123456789012:token-vault/default/apikeycredentialprovider/my-github-pat"
},
}
}
]
```
Allega una skill da un repository Git pubblico con`agentcore add skill`. `--git-path`Usalo per estrarre una singola abilità da una sottodirectory:
```
agentcore add skill --harness my-harness \
--git https://github.com/anthropics/skills \
--git-path skills/docx
agentcore deploy
```
Per un repository privato, inserite il nome di una credenziale di chiave API del progetto che contiene un token di accesso personale (`--username`è facoltativo, predefinito): `--credential` `oauth2`
```
agentcore add skill --harness my-harness \
--git https://github.com/my-org/internal-skills \
--git-path excel \
--credential my-github-pat
agentcore deploy
```
Rimuovi un'abilità `agentcore remove skill` usando gli stessi flag di origine. Per sovrascrivere le abilità per una singola chiamata senza modificare l'harness, usa `agentcore invoke --skills ` (percorsi separati da virgole`s3://`, URI o `https://` URL Git); l'autenticazione Git non è supportata nell'override di invoke.
Nella TUI, aggiungi un'abilità Git a un cablaggio tramite la procedura guidata **aggiungi** → **Harness**.
1. **Passa alle **impostazioni avanzate**, passa a **Skills** e premi la barra **spaziatrice** per abilitarla, quindi premi Invio.**
1. Seleziona **Git** come fonte di abilità.
1. Inserisci l'URL del repository HTTPS. La procedura guidata richiede quindi un percorso di sottodirectory opzionale, una credenziale opzionale per gli archivi privati e un nome utente opzionale.
Conferma la procedura guidata, quindi esegui `agentcore deploy` per applicare.
+ `url`(obbligatorio) - URL HTTPS del repository Git.
+ `path`(opzionale) - sottodirectory all'interno del repository contenente l'abilità. Se omesso, viene utilizzata la radice del repository.
+ `auth.credentialArn`(opzionale) - ARN di un fornitore di credenziali di chiave API che possiede un token di accesso personale per repository privati.
+ `auth.username`(opzionale) - git username, il valore predefinito è. `oauth2`
Il recupero di Git deve essere completato entro 60 secondi. Se il repository richiede l'uscita da Internet, assicurati che il tuo VPC disponga di un gateway NAT (stesso requisito dei server MCP remoti e dei container pull personalizzati).
## Competenze di Amazon S3
Recupera una skill da un bucket S3 di proprietà del cliente. Utilizza le credenziali del ruolo di esecuzione di Harness.
**Example**
```
response = client.invoke_harness(
harnessArn=HARNESS_ARN,
runtimeSessionId=SESSION_ID,
skills=[
{"s3": {"uri": "s3://my-skills-bucket/skills/company-style/"}},
],
messages=[{"role": "user", "content": [{"text": "Draft a summary following our style guide."}]}],
)
```
Associa un'abilità da S3 con: `agentcore add skill --s3`
```
agentcore add skill --harness my-harness \
--s3 s3://my-skills-bucket/skills/company-style/
agentcore deploy
```
Il ruolo di esecuzione è necessario `s3:GetObject` e `s3:ListBucket` pronto all'uso. Per informazioni, consulta [Sicurezza e controlli degli accessi](harness-security.md).
**Nella TUI, aggiungi un'abilità S3 a un cablaggio tramite la procedura guidata **Aggiungi** → Harness.** Passa alle **impostazioni avanzate**, abilita **Skills** with **Space** e scegli **S3** come sorgente (vedi la scheda [Git](#harness-skills-git) Interactive per quei passaggi condivisi).
1. Inserisci l'URI S3 della directory delle abilità.
Conferma la procedura guidata, quindi `agentcore deploy` esegui l'applicazione.
+ `uri`(richiesto) - URI S3 che punta alla directory delle abilità (ad es.). `s3://bucket/prefix/`
+ Il ruolo di esecuzione deve disporre di autorizzazioni `s3:GetObject` e `s3:ListBucket` autorizzazioni sul bucket. Per informazioni, consulta [Sicurezza e controlli degli accessi](harness-security.md).
+ Ogni skill S3 deve pesare almeno 1 GB.
+ Le sorgenti S3 funzionano con gli endpoint VPC S3 (non è richiesto alcun gateway NAT).
## Competenze relative ai percorsi del file system
Fai riferimento a un'abilità già presente nel filesystem harness, inserita nell'immagine del contenitore o installata all'avvio della sessione tramite. `InvokeAgentRuntimeCommand`
**Example**
```
response = client.invoke_harness(
harnessArn=HARNESS_ARN,
runtimeSessionId=SESSION_ID,
skills=[{"path": ".agents/skills/xlsx"}],
messages=[{"role": "user", "content": [{"text": "Find errors in the Excel files."}]}],
)
```
### Infornate nell'immagine del contenitore
Includi la cartella delle abilità nell'immagine personalizzata:
```
COPY skills/xlsx .agents/skills/xlsx
```
### Installa all'inizio della sessione
Utilizzare `InvokeAgentRuntimeCommand` prima della prima chiamata dell'agente:
```
agentcore invoke --exec --harness my-agent --session-id "$SESSION" \
"git clone --depth 1 https://github.com/anthropics/skills /tmp/skills && cp -r /tmp/skills/skills/xlsx .agents/skills/xlsx"
```
## Combina più fonti di abilità
Tutti e quattro i tipi di sorgenti possono coesistere in un unico payload:
```
response = client.invoke_harness(
harnessArn=HARNESS_ARN,
runtimeSessionId=SESSION_ID,
skills=[
{"awsSkills": {"paths": ["core-skills/aws-cdk"]}},
{"git": {"url": "https://github.com/anthropics/skills", "path": "skills/docx"}},
{"s3": {"uri": "s3://my-bucket/skills/company-style/"}},
{"path": ".agents/skills/xlsx"},
],
messages=[{"role": "user", "content": [{"text": "Help me with this project."}]}],
)
```
## Gestione degli errori
Tutti gli errori di recupero non riescono a completare la chiamata con un errore descrittivo. Le abilità non vengono mai ignorate silenziosamente.
| Errore | Messaggio di errore |
| --- | --- |
| Accesso S3 negato | `Failed to fetch skill: AccessDeniedException. Ensure execution role has s3:GetObject permission.` |
| Oggetto S3 non trovato | `Skill source not found: s3://…` |
| Git clone fallisce (rete) | `Failed to clone skill: could not resolve host` |
| Autenticazione Git negata | `Failed to clone skill: authentication failed` |
| Percorso Git non trovato nel repository | `Skill path 'x' not found in repository` |
| Timeout Git (60 minuti) | `Failed to clone skill: operation timed out after 60s` |
| Skill supera il limite di 1 GB | `Skill exceeds 1GB size limit` |
| AWS il percorso delle abilità non corrisponde a nulla | `AWS skill path 'x' matched no skills` |
| Percorso di attraversamento () `..` | `Invalid AWS skill path: must be a relative path without '..'` |
| AWS pacchetto di competenze mancante | `AWS Skills are not available in this runtime (missing directory: /opt/amazon/skills)` |
### Argomenti correlati
+ [Tools (Strumenti)](harness-tools.md)- collega server MCP, Gateway, Browser e Code Interpreter
+ [Ambiente e file system](harness-environment.md)- immagini personalizzate dei contenitori e configurazione dell'ambiente
+ [Memoria](harness-memory.md)- persistono le conversazioni tra le sessioni
+ [Sicurezza e controlli degli accessi](harness-security.md)- politiche relative ai ruoli di esecuzione per le fonti di competenze
+ [Documentazione API](harness-get-started.md#api-documentation)