

# Erste Schritte mit Amazon Bedrock AgentCore
<a name="agentcore-get-started-cli"></a>

Mit diesem Schnellstart gelangen Sie mithilfe der AgentCore CLI in wenigen Minuten von Null auf einen laufenden Agenten. Sie installieren die CLI, erstellen ein Gerüst für ein Projekt, testen lokal, implementieren es auf Ihrem Agenten AWS und rufen ihn auf.

Es gibt zwei Möglichkeiten, einen Agenten auf AgentCore derselben CLI zu erstellen:
+  **Verwalteter Kabelbaum**. Sie deklarieren den Agenten in einer Konfigurationsdatei (Modell, Eingabeaufforderung, Tools, Speicher) und führen AgentCore die Schleife für Sie aus. Kein Framework, kein Orchestrierungscode. Guter Pfad, wenn Sie den schnellsten Weg von der Idee zum laufenden Agenten suchen. [Weitere Informationen](harness.md).
+  **Code-based Agent**. Sie schreiben die Agentenschleife in Python mit einem Framework, das Sie bereits kennen (Strands LangGraph, Google ADK oder OpenAI Agents), und stellen sie in Runtime bereit. AgentCore Volle Kontrolle über die Orchestrierungslogik.

Auf dieser Seite wird der codebasierte Ablauf beschrieben. Informationen zum Kabelbaum finden Sie unter [Was ist ein](harness.md) Kabelbaum. AgentCore 

## Melden Sie sich an für ein AWS Konto
<a name="sign_up_for_an_shared_id_aws_account"></a>

### Melde dich an für ein AWS Konto
<a name="sign-up-for-aws"></a>

Um loszulegen AWS, benötigen Sie ein AWS Konto. Informationen zum Erstellen eines AWS Kontos finden Sie unter [Erste Schritte mit einem AWS Konto](https://docs.aws.amazon.com/accounts/latest/reference/getting-started.html) im *Referenzhandbuch zur AWS Kontoverwaltung*.

## Voraussetzungen
<a name="agentcore-cli-prerequisites"></a>
+  **Node.js 20 oder später.** Die AgentCore CLI wird als npm-Paket verteilt. Erkundigen Sie sich bei`node --version`. Bei Bedarf von [nodejs.org](https://nodejs.org) installieren.
+  **npm.** Enthalten bei Node.js.
+  **Ein AWS Konto mit konfigurierten Anmeldeinformationen.** Konfiguration über AWS CLI, Umgebungsvariablen oder ein AWS Profil. Siehe [Konfiguration der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html).
+  **Python 3.10 oder höher** (für Agentencode). Erkundigen Sie sich bei`python3 --version`.
+  **IAM-Berechtigungen.** Ihre Identität benötigt Berechtigungen, um AgentCore API-Aufrufe zu tätigen und die CDK-Bootstrap-Rollen zu übernehmen, die während der Bereitstellung verwendet wurden. Siehe [AgentCore CLI-IAM-Berechtigungen](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/security-iam.html).

## Schritt 1: AgentCore CLI installieren
<a name="agentcore-cli-install"></a>

```
npm install -g @aws/agentcore
```

Überprüfen:

```
agentcore --version
```

Um später zu aktualisieren, führen Sie den Installationsbefehl erneut aus oder`agentcore update`. Quelle und Probleme: [agentcore-cli](https://github.com/aws/agentcore-cli) aktiviert. GitHub

## Schritt 2: Erstellen Sie Ihr Projekt
<a name="agentcore-cli-create"></a>

```
agentcore create
```

Der interaktive Assistent fragt Sie zunächst, was Sie erstellen möchten:
+  **Harness** — Eine verwaltete, konfigurationsbasierte Agentschleife. Kein Framework oder Orchestrierungscode erforderlich. Weitere Informationen finden Sie unter [Was ist der AgentCore Kabelbaum](harness.md).
+  **Agent** — Ein codebasierter Agent, der ein Framework Ihrer Wahl verwendet und in Runtime bereitgestellt wird. AgentCore 
+  **Skip** — Erstellen Sie die Projektstruktur ohne Agenten. Fügen Sie später einen hinzu mit`agentcore add`.

Wenn Sie **Agent** wählen, fährt der Assistent fort mit:
+  **Framework** — Strands Agents (empfohlen) LangChain/LangGraph, Google Agent Development Kit oder OpenAI Agents SDK
+  **Modellanbieter** — Amazon Bedrock, Anthropic, OpenAI oder Gemini
+  **Speicher** — Keines, nur kurzfristig oder langfristig und kurzfristig
+  **Buildtyp** — CodeZip (Standard) oder Container

Sie können Flags auch direkt übergeben, um einen codebasierten Agenten zu erstellen:

```
agentcore create \
  --name MyAgent \
  --framework Strands \
  --model-provider Bedrock \
  --memory none \
  --build CodeZip
```

### Struktur des Projekts
<a name="agentcore-cli-project-structure"></a>

 `agentcore create`generiert:

```
MyAgent/
├── agentcore/
│   ├── agentcore.json      # Project and resource configuration
│   ├── aws-targets.json    # Deployment target (account and region)
│   └── cdk/                # CDK infrastructure (auto-managed)
└── app/
    └── MyAgent/            # Your agent code
        ├── main.py         # Agent entrypoint
        ├── pyproject.toml  # Python dependencies
        └── ...
```

Wichtige Dateien:
+  `agentcore/agentcore.json`- die Hauptkonfiguration. Definiert Ihre Agenten, Speicherspeicher, Gateways, Anmeldeinformationen und andere Ressourcen. Verwaltet von `agentcore add` und. `agentcore remove`
+  `app/`- Ihr Agentencode. Jeder Agent erhält sein eigenes Unterverzeichnis mit einem Einstiegspunkt und einem. `pyproject.toml`
+  `agentcore/aws-targets.json`- das AWS Konto und die Region für die Bereitstellung.

## Schritt 3: Lokal testen
<a name="agentcore-cli-test"></a>

```
cd MyAgent
agentcore dev
```

 `agentcore dev`erstellt eine virtuelle Python-Umgebung, installiert Abhängigkeiten, startet einen lokalen Server mit Hot-Reload und öffnet den **Agenteninspektor** in Ihrem Browser, sodass Sie mit dem Agenten chatten, Traces überprüfen und Projektressourcen durchsuchen können. Codeänderungen werden automatisch übernommen.

Nützliche Flaggen:
+  `--no-browser`- Verwenden Sie die terminalbasierte Benutzeroberfläche anstelle des Browser-Inspectors.
+  `--no-traces`- deaktiviert das Schreiben von Traces auf. `agentcore/.cli/traces`
+  `--logs`- Protokolldateien des Tailservers im nicht interaktiven Modus.
+  `--port <N>`- den Dev-Port anpinnen (Standard 8080 für HTTP, 8000 für MCP, 9000 für A2A; wird automatisch erhöht, wenn ausgelastet).

## Schritt 4: Stellen Sie Ihren Agenten bereit
<a name="agentcore-cli-deploy"></a>

```
agentcore deploy
```

Bereitstellen:

1. Packt deinen Code in ein ZIP-Artefakt (oder baut einen Container, falls`--build Container`)

1. Nutzt AWS CDK unter der Haube, um Ressourcen zu synthetisieren und bereitzustellen

1. Erstellt einen AgentCore Runtime-Endpunkt für Ihren Agenten

1. Konfiguriert CloudWatch Protokollierung und Beobachtbarkeit

Die erste Bereitstellung dauert einige Minuten, während CDK Ihr Konto bootet. Nachfolgende Bereitstellungen sind schneller.

Sehen Sie sich in einer Vorschau an, was sich ohne Bereitstellung ändern wird:

```
agentcore deploy --dry-run
```

Status überprüfen:

```
agentcore status
```

## Schritt 5: Rufen Sie Ihren bereitgestellten Agenten auf
<a name="agentcore-cli-invoke"></a>

```
agentcore invoke --prompt "Hello, what can you do?"
```

Wenn Ihr Agent Zahlungen konfiguriert hat, geben Sie zum Zeitpunkt des Aufrufs den Zahlungskontext an:

```
agentcore invoke \
  --prompt "Access https://example-x402-merchant.com/paid-api" \
  --payment-instrument-id <INSTRUMENT_ID> \
  --auto-session \
  --payment-user-id user@example.com
```

Das ist die Schleife. Iterieren`app/MyAgent/main.py`, testen mit`agentcore dev`, bereitstellen mit`agentcore deploy`, aufrufen mit. `agentcore invoke`

## Fügen Sie Ihrem Projekt Funktionen hinzu
<a name="agentcore-cli-add-capabilities"></a>

 `agentcore add`verwaltet Ressourcen in`agentcore.json`. Führt es ohne Argumente für das interaktive Menü aus oder zielt direkt auf eine Ressource ab.

```
agentcore add memory        # Store conversation context
agentcore add agent         # Add a second agent to the same project
agentcore add gateway       # Connect external APIs/tools through Gateway
agentcore add credential    # Add an API key for a non-Bedrock provider
agentcore add evaluator     # Quality evaluation
agentcore add payment-manager   # Payments: create a payment manager
agentcore add payment-connector # Payments: link a payment provider
```

Jeder Befehl add bildet das Gerüst für die Konfiguration und fordert zur Eingabe der erforderlichen Werte auf. Führen `agentcore deploy` Sie nach dem Hinzufügen den Befehl zur Bereitstellung aus.

Detaillierte Informationen zu den Funktionen, die Sie hinzufügen können:
+  [AgentCore Gedächtnis](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/memory.html) — Kurzzeit- und Langzeitgedächtnis, Abrufstrategien
+  [AgentCore Gateway](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway.html) — geregelte Konnektivität zu APIs und MCP-Servern
+  [AgentCore Browser](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/browser-tool.html) — verwaltetes Surfen im Internet für Agenten
+  [AgentCore Codeinterpreter — Ausführung](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/code-interpreter-tool.html) von Code in einer Sandbox
+  [AgentCore Identität](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/identity.html) — OAuth, Anbieter von API-Schlüsselanmeldedaten, Workload-Identität
+  [AgentCore Beobachtbarkeit](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/observability.html) — Traces, Logs und Metriken in CloudWatch
+  [AgentCore VPC](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/agentcore-vpc.html) — Agenten in Ihrer VPC ausführen
+  [AgentCore Zahlungen](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/payments.html) — Mikrotransaktionszahlungen für Agenten über x402

## Logs und Traces anzeigen
<a name="agentcore-cli-logs"></a>

```
# Stream recent logs
agentcore logs

# Filter
agentcore logs --since 30m --level error
agentcore logs --query "timeout"

# List recent traces
agentcore traces list

# Get a specific trace
agentcore traces get <trace-id>
```

## Bereinigen
<a name="agentcore-cli-cleanup"></a>

```
agentcore remove all
agentcore deploy
```

 `remove all`setzt die Konfiguration zurück. Das Follow-up `deploy` erkennt, dass der Status leer ist, und reduziert die Ressourcen in Ihrem Konto.

## Nächste Schritte
<a name="agentcore-cli-next-steps"></a>
+  [Was ist der AgentCore Harness](harness.md) — der konfigurationsbasierte Pfad zu einem laufenden Agenten. Verwenden Sie ein beliebiges Modell, stellen Sie eine Verbindung zu Tools her, behalten Sie den Status bei, stellen Sie es in Ihrer VPC bereit und beginnen Sie bei Bedarf mit dem Programmieren.
+  [AgentCore Codebeispiele](https://github.com/awslabs/amazon-bedrock-agentcore-samples) — umfassende Beispiele für alle Frameworks und Funktionen.