Zum Inhalt springen
AggregaAggrega
Sprache wählen: Deutsch
Diese Seite wurde maschinell übersetzt. Das englische Original lesen.

Einen deklarativen Agenten von Microsoft Agent Framework importieren

Diese Schritt-für-Schritt-Anleitung importiert einen deklarativen Agenten von Microsoft Agent Framework — einen Assistenten, der Fragen anhand von Dokumentation beantwortet, die er über einen MCP-Server durchsucht — und baut die Anwendung für Docker Compose. Der Import entwirft jede Datei, die der Build liest: den Agenten und sein Modell, den Schlüssel, den der Agent dem Modell vorlegt, als Variablenreferenz, und die Realisierungen jedes einzelnen. Er fragt einmal nach dem einen Wert, den kein deklarativer Agent enthält: dem Image, in dem Ihre Anwendung läuft. Jede Datei und jeder Ausgabeblock unten stammt aus einem echten Lauf; der deklarative Agent und jede Stufe der Anleitung befinden sich im Beispiel import-agent-framework, in dem ein Prüfskript den Import erneut ausführt, das, was er schreibt, was er ausgibt und die Blöcke, die diese Seite zitiert, mit den dort abgelegten Dateien vergleicht und das, was der Import geschrieben hat, validiert und baut.

Das Beispiel generieren

Sie können diesen Import mit den Befehlen auf dieser Seite ausführen oder ihn von Ihrem KI-Assistenten ausführen lassen.

Schreiben Sie das Beispiel in einen neuen Ordner, der nach ihm benannt ist:

Terminal window
aggrega scaffold --example import-agent-framework

Danach gibt er die als Nächstes auszuführenden Befehle aus. Der erste wechselt in den neuen Ordner; der folgende, unten, wechselt in den Ordner source des neuen Ordners, der enthält, was diese Seite importiert, und in dem der Import läuft:

Terminal window
cd import-agent-framework

Der source-Ordner des erzeugten Beispiels, geöffnet in Visual Studio Code, mit dem Prompt-Agenten SupportAgent, seinem OpenAI-Modell und seinem MCP-Tool für Microsoft Learn.

Das Projekt

Eine auf Agent Framework aufgebaute Anwendung kann einen Agenten aus einem deklarativen Agenten laden: einem YAML-Dokument der Art Prompt, das das Modell des Agenten, seine Anweisungen und seine Werkzeuge benennt. Dieser hier, für diese Anleitung geschrieben, benennt gpt-4.1-mini von OpenAI und den MCP-Server, den Microsoft Learn veröffentlicht:

kind: Prompt
name: SupportAgent
displayName: Support Assistant
description: Answers a customer's question about the product from its documentation.
instructions: You answer customers' questions about the product, from its documentation only.
model:
id: gpt-4.1-mini
provider: OpenAI
apiType: Responses
options:
temperature: 0.2
connection:
kind: key
key: =Env.OPENAI_API_KEY
tools:
- kind: mcp
name: microsoft_learn
description: Search Microsoft's documentation on Microsoft Learn.
url: https://learn.microsoft.com/api/mcp
approvalMode:
kind: never
allowedTools:
- microsoft_docs_search
- microsoft_docs_fetch

Der Schlüssel des Modells ist als =Env.OPENAI_API_KEY geschrieben, sodass die Datei keinen Schlüssel enthält. Agent Framework liest diesen Ausdruck nur dort aus der Umgebungsvariablen OPENAI_API_KEY, wo die Anwendung den deklarativen Agenten mit AgentFactory(safe_mode=False), der eigenen Sicherheitseinstellung von Agent Framework, lädt und eine .NET-Laufzeitumgebung vorhanden ist; andernfalls ist der Schlüssel der Text des Ausdrucks, so wie er geschrieben ist. Der Code der Anwendung, der den deklarativen Agenten lädt, wird vom Import nie gelesen und ist nicht Teil des Beispiels. Neben der Datei macht eine .aggrega-config.yaml den Ordner zu einem Workspace:

# The workspace key marks this directory as the workspace root, so an import run
# here writes its drafts beside support-agent.yaml.
workspace: {}
# The registry the importer is fetched from the first time an import needs it.
default_registry: hub.aggrega.ai

Der Import referenziert die Components des Katalogs für den Agent-Framework-Agenten und das OpenAI-Modell, und --target entwirft aus dessen Recipes ein Manifest. Der Arbeitsbereich nennt keinen Katalogordner, daher liest der Import den Katalog der Standardbibliothek aus der Registry, aus der er seinen Importer holt: einen signierten Snapshot des veröffentlichten Katalogs, den der erste Import holt, verifiziert und im Content-Cache des Arbeitsbereichs ablegt und der über seinen Digest in der Aufzeichnung benannt wird, die der Import neben seine Entwürfe schreibt. Ein Arbeitsbereich, der eigene Katalogordner nennt — in AGGREGA_CATALOG_DIRS oder unter workspace.catalog_dirs —, importiert stattdessen gegen diese.

Wonach der Import fragt

Ein deklarativer Agent nennt sein Modell, nie das Image, in dem die Anwendung läuft: Dieses Image bauen Sie aus Ihrem Projekt. Der Katalog enthält kein Standard-Image für eine auf Agent Framework aufgebaute Anwendung, daher fragt der Import danach. In einem Terminal ohne vorliegende Antwort ausgeführt, fragt er:

The drafts leave values empty that the source cannot hold. Answer each one, or press Enter to leave it for later in the answers file:
release.yaml spec.components.supportagent.infra.image
Container image running the application built on Microsoft Agent Framework.
>

und schreibt die Antwort in die Entwürfe und in import-answers.yaml neben support-agent.yaml, sodass der nächste Import sie von dort liest und nichts fragt. Ohne Terminal — in der kontinuierlichen Integration oder über eine Pipe — fragt er nichts: Er schreibt die Datei mit leerem Schlüssel und hält an, wobei er die Datei nennt. Das Beispiel enthält die Datei bereits, mit beantwortetem Image, ghcr.io/example/support-agent:1.0.0, das für das Image steht, das Sie bauen:

# Values the import could not draft from the source, keyed by the drafted file and the key path inside
# it. Write each one beside its key; an import of the same source, and a sync, read them from here and
# ask nothing. A secret is never written here: its key asks where the secret comes from — a variable
# name, ${NAME}, or the name of a Kubernetes Secret.
release.yaml:
# Container image running the application built on Microsoft Agent Framework.
spec.components.supportagent.infra.image: "ghcr.io/example/support-agent:1.0.0"
# The origin of the secret value, written by the operator in the Release. Read exactly as
# values.origin is. Write it here or in values.origin, never in both. A secret: name where it comes
# from, never the value.
spec.components.supportagent.uses.model.gpt-4-1-mini.features.credential.infra.origin: "openai-api-key"

Die zweite Antwort gilt für einen Build für Kubernetes mit --target helm: Dort liest der Agent den OpenAI-Schlüssel aus einem Kubernetes-Secret, und die Antwort ist der Name des Secrets, openai-api-key, nie der Schlüssel. Ein Build für Docker Compose liest den Schlüssel stattdessen aus Ihrer Shell, daher verwendet dieser Import diese Antwort nicht. Die Antwortdatei des Imports beschreibt die Datei, die Fragen und die Regeln für die Antwort auf ein Geheimnis.

aggrega import listet jedes Flag auf, das der Befehl annimmt, darunter --answers, das eine anderswo abgelegte Antwortdatei nennt.

Wechseln Sie in source:

Terminal window
cd source

Den Import ausführen

Geben Sie die Datei des deklarativen Agenten an. Der Import liest jeden deklarativen Agenten als eigene Datei und nie als Verzeichnis:

Terminal window
aggrega import support-agent.yaml --target compose

Auf der Standardausgabe listet er auf, was er geschrieben hat:

wrote aggregate.yaml
wrote release.yaml
wrote manifest.yaml
wrote .aggrega-import.json

Auf der Standardfehlerausgabe, wobei <workspace> für den Ordner steht, in dem Sie ihn ausgeführt haben:

[… omitted: a warning that the importer runs unverified, printed where its module is read from beside its Plugin entity in a catalog folder rather than fetched]
read as the agent-framework format, with drafted paths relative to <workspace>
warn: the value of tools.microsoft_learn.url of node SupportAgent is carried as written in the Release the draft writes: the field belongs to an MCP server's configuration, which can carry a key, and setting empty_credentials to marked or all writes it empty
info: the answers file <workspace>/import-answers.yaml also answers spec.components.supportagent.uses.model.gpt-4-1-mini.features.credential.infra.origin in release.yaml, which these drafts do not leave empty; those answers are kept there and not applied
mapped SupportAgent (agent) to core/ai-agent/agent-framework as a reference, NONE
mapped gpt-4.1-mini (model) to core/ai-model/openai as a reference, NONE
made no choice for SupportAgent#microsoft_learn (tool)
Pull complete: <workspace>/release.lock (entities=8, source_artifacts=0, external_inputs=0)

Der Import, aus dem Editor ausgeführt: Das entworfene Aggregate, das Release und das Manifest erscheinen neben dem deklarativen Agenten, die Aggrega-Ausgabe listet auf, wie der Agent und sein Modell abgebildet wurden und welche Dateien geschrieben wurden, und eine Benachrichtigung meldet, dass der Import 3 Dateien entworfen hat, erkannt als agent-framework.

  • Die warn-Zeile benennt einen Wert, der einen Schlüssel enthalten kann — die Adresse eines MCP-Servers —, und sagt, dass er so übernommen wird, wie er geschrieben ist. Diese Adresse enthält keinen.
  • Die info-Zeile nennt die Antwort, die die Docker-Compose-Entwürfe nicht verwenden und die in der Antwortdatei für einen Build für Kubernetes aufbewahrt wird.
  • Die mapped-Zeilen besagen, dass der Agent eine Instanz des Agent-Framework-Agenten der Standardbibliothek ist, core/ai-agent/agent-framework, und sein Modell eine Instanz von core/ai-model/openai. Ihre Stufe lautet NONE: Der Agent-Framework-Import referenziert diese Components anhand dessen, was der deklarative Agent benennt, statt jede gegen den Katalog abzuwägen.
  • Die made no choice-Zeile ist der MCP-Server, für den der Import keine Component entwirft, aus dem Grund, den die Kommentare in aggregate.yaml angeben.
  • Die Zeile Pull complete zeigt, dass der Import das, wovon das entworfene Release abhängt, wie aggrega pull in release.lock abruft, sodass die Entwürfe sofort validiert und gebaut werden können. Mit --offline ruft der Import nichts ab und nennt den auszuführenden Befehl aggrega pull.

Was er schreibt

Das Aggregate, das Release und das Manifest heißen imported/supportagent, nach dem name des Agenten, SupportAgent, reduziert auf supportagent — sein displayName wird nicht gelesen —, unter dem Namespace, den die Einstellung target_namespace des Importers festlegt, imported, sofern Sie keinen anderen festlegen (Einstellungen).

aggregate.yaml — der Agent, verdrahtet mit seinem Modell, wobei der Schlüssel, den er vorlegt, an der Verbindung deklariert ist, und das Modell:

# Not read: the application's code, which loads each declarative agent and binds the functions of its function tools; the application runs in the image the Release names for each instance, and loads its declarative agents itself.
apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
name: imported/supportagent
version: 0.1.0
description: Draft Aggregate imported from a source in the agent-framework format.
spec:
components:
# The declarative agent SupportAgent.
# Read by the application from the declarative agent, and taken by no key of core/ai-agent/agent-framework: instructions, the options of its model requests (temperature).
# The MCP server microsoft_learn, drafted as no Component and no connection, since Agent Framework sends it to the model's provider as a hosted tool, and the provider, not the application, reaches it at its url, which must therefore be reachable from the provider; its url is written above supportagent's entry in the Release.
# Stated by the declarative agent for microsoft_learn: its description, "Search Microsoft's documentation on Microsoft Learn."; its approval mode, never; the tools of the server it allows, microsoft_docs_search, microsoft_docs_fetch.
supportagent:
type: core/ai-agent/agent-framework
values:
display_name: "Support Assistant"
description: "Answers a customer's question about the product from its documentation."
uses:
model:
gpt-4-1-mini:
target: gpt-4-1-mini
# For the compose target, the lines below declare credential on gpt-4-1-mini: a secret the Release alone attaches arrives under the key value, so each is declared with a key of its own and no two arrive under one; the Release attaches its origin, naming this type or none.
features:
credential:
type: core/secret-value
values:
key: OPENAI_API_KEY
# The model gpt-4.1-mini, which SupportAgent names with the OpenAI provider.
gpt-4-1-mini:
type: core/ai-model/openai
values:
model: "gpt-4.1-mini"

Der MCP-Server ist keine Component und keine Verbindung des Agenten: Agent Framework sendet ihn als gehostetes Werkzeug an den Anbieter des Modells, und der Anbieter, nicht die Anwendung, erreicht ihn unter seiner url, die daher vom Anbieter aus erreichbar sein muss. Die Anweisungen, die Optionen der Anfragen an das Modell sowie die Beschreibung, der Genehmigungsmodus und die erlaubten Werkzeuge des Servers bleiben im deklarativen Agenten, den die Anwendung liest; die Kommentare nennen jedes davon. Die API von OpenAI ist ein gehosteter Dienst, daher lehnt die Component des Agenten eine Verbindung dorthin ab, die keine Anmeldeinformation trägt; die Verbindung deklariert eine, unter dem Schlüssel OPENAI_API_KEY, der Variablen, aus der der deklarative Agent seinen Schlüssel liest.

release.yaml — die Umgebung, das Image, der veröffentlichte Port und woher der Schlüssel stammt:

apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
name: imported/supportagent
# environment is a drafted default, since no source names the environment this Release deploys to; change it to name the one it deploys to.
environment: development
version: 0.1.0
description: Draft Release imported from a source in the agent-framework format.
spec:
aggregate: imported/supportagent
manifest: imported/supportagent
components:
# The declarative agent also states these values for its model and its MCP servers, written here for review:
# - model.connection.key, written as =Env.OPENAI_API_KEY, which Agent Framework reads from the environment variable OPENAI_API_KEY only where the application loads the declarative agent with AgentFactory(safe_mode=False), Agent Framework's own security setting, and a .NET runtime is present; otherwise the value is the expression's text as written
# - tools.microsoft_learn.url: "https://learn.microsoft.com/api/mcp"
supportagent:
infra:
# Left for the Release, since the source cannot supply it: infra.image, the container image running the application built on Agent Framework, holding its declarative agent
image: "ghcr.io/example/support-agent:1.0.0"
# Published on this machine's loopback address, 127.0.0.1: reachable from this machine only, by any process running on it. Delete this line to keep the service internal.
published_port: 8000
uses:
model:
gpt-4-1-mini:
features:
credential:
type: core/secret-value
infra:
# Attached by reference, never as a value: the credential supportagent presents to gpt-4-1-mini on its model connection, read from the variable OPENAI_API_KEY, which a target substituting variable references, as Docker Compose does when the stack starts, reads from the environment, so no file carries the value.
origin: "${OPENAI_API_KEY}"
gpt-4-1-mini: {}

Die Umgebung, development, ist ein Standardwert, den der Import schreibt, weil kein deklarativer Agent eine nennt; ändern Sie ihn, wenn das Release anderswohin deployt. Das Image ist die Antwort, die der Import aus import-answers.yaml gelesen hat. Der Agent wird auf der Loopback-Adresse Ihres Rechners veröffentlicht, auf Port 8000, und leitet an den Port weiter, auf dem sein Programm lauscht, infra.port, 8000, sofern Sie ihn nicht setzen. Der Schlüssel ist die Variablenreferenz ${OPENAI_API_KEY}, benannt nach der Variablen, die der deklarative Agent liest, nie ein Wert. Die Adresse des MCP-Servers wird so geschrieben, wie der deklarative Agent sie angibt, zur Prüfung, und nirgendwo sonst gesetzt: Agent Framework übergibt sie dem Anbieter in seiner Anfrage an das Modell.

manifest.yaml — das Compose-Recipe des Agenten und des Modells sowie die Realisierung, die die Variablenreferenz des Schlüssels unverändert in die Compose-Datei schreibt:

apiVersion: aggrega.ai/v1beta1
kind: Manifest
metadata:
name: imported/supportagent
version: 0.1.0
spec:
mappings:
components:
type:
core/ai-agent/agent-framework: compose/agent-framework
core/ai-model/openai: compose/openai
features:
type:
core/secret-value: compose/dotenv-secret

release.lock hält per Digest die Katalog-Entitäten fest, zu denen das Release aufgelöst wurde, und .aggrega-import.json ist die Aufzeichnung dessen, was der Import geschrieben hat, und wird von einem späteren aggrega import --sync gelesen.

Validieren und bauen

Terminal window
aggrega validate --release release.yaml
aggrega build --release release.yaml

Das entworfene Release, nach der Validierung im Editor geöffnet; die Aggrega-Ausgabe und eine Benachrichtigung melden beide, dass keine Probleme gefunden wurden.

Der Build des entworfenen Release: Im Explorer erscheint ein dist-Ordner, die Aggrega-Ausgabe listet die geschriebene Docker-Compose-Datei auf, und eine Benachrichtigung meldet, dass 1 Datei geschrieben wurde.

Die Validierung gibt aus:

notice: LINT: Feature "core/secret-value" at core/secret-value:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)
release dependency validation passed: release.yaml (schema-pillar + dependency pillars)

und der Build, wobei <workspace> für den Ordner steht, in dem Sie ihn ausgeführt haben:

notice: LINT: Feature "core/secret-value" at core/secret-value:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)
[… omitted: a total build time, which differs per run]
Build completed: 1 file written to <workspace>/dist

Die notice-Zeile ist ein Hinweis: Das Secret-Feature akzeptiert sein origin aus den values des Aggregate oder aus der infra des Release, und der Hinweis meldet, dass ein Blatt in beiden deklariert ist. Er ändert kein Urteil.

Der Dienst des Agenten in dist/compose/docker-compose.yaml:

services:
supportagent:
image: ghcr.io/example/support-agent:1.0.0
environment:
OPENAI_BASE_URL: https://api.openai.com/v1
OPENAI_MODEL: gpt-4.1-mini
OPENAI_API_KEY: ${OPENAI_API_KEY}
ports:
- 127.0.0.1:8000:8000
[… omitted: the labels the build writes on every service, naming the Aggregate, the component, the environment and the compiler's version]
networks:
- compose

Die Anwendung erhält die Adresse des Modells, seinen Namen und seinen Schlüssel in den Variablen, die die OpenAI-Clients von Agent Framework lesen, sodass das =Env.OPENAI_API_KEY des deklarativen Agenten den Schlüssel liest, den das Release angehängt hat, wo die Anwendung den Agenten so lädt, wie Das Projekt beschreibt. Keine Variable enthält die Adresse des MCP-Servers, den der Anbieter erreicht. Das Modell erhält keinen eigenen Dienst: Der Agent erreicht die OpenAI-API unter deren eigener Adresse. Der Schlüssel ist eine Variablenreferenz, die beim Start des Stacks aus Ihrer Shell befüllt wird. Der Dienst veröffentlicht seinen Port nur auf 127.0.0.1.

Mit einem KI-Assistenten

Ein KI-Assistent, der mit den Tools von Aggrega eingerichtet ist, kann dasselbe tun: Fügen Sie diesen Prompt dort ein.

Verwenden Sie nur die Aggrega-Tools und legen Sie selbst keinen Ordner an. Wenn der Workspace-Ordner noch keinen Ordner `import-agent-framework` enthält, rufen Sie das Tool `scaffold` einmal auf, mit `example` auf `import-agent-framework` gesetzt und ohne `dir`: Es schreibt das Beispiel in einen neuen Ordner `import-agent-framework`, dessen Ordner `source` enthält, was diese Seite importiert. Rufen Sie dann das Tool `import` auf, mit `workspace_root` auf `import-agent-framework/source`, `source` auf `support-agent.yaml` und `target` auf `compose` gesetzt: Es liest die benötigten Antworten aus `import-answers.yaml` neben `support-agent.yaml`, schreibt seine Entwürfe nach `import-agent-framework/source` und lädt, was sie benötigen. Rufen Sie dann das Tool `validate` auf, mit `workspace_root` auf `import-agent-framework/source` und `release` auf `release.yaml` gesetzt, und das Tool `build`, mit `workspace_root` auf `import-agent-framework/source`, `release` auf `release.yaml` und `write` auf true gesetzt. Sagen Sie mir, welche Dateien der Build geschrieben hat; sie liegen unter `import-agent-framework/source/dist/`.

In VS Code öffnen

Ist die Aggrega-Erweiterung für Visual Studio Code installiert, öffnen Sie in VS Code den Ordner import-agent-framework/source, in den der Import seine Entwürfe geschrieben hat. Der Ordner enthält ein einziges Release, das entworfene release.yaml, daher wählt der Editor es für Sie aus und prüft die Entwürfe beim Bearbeiten gegen dieses Release, wobei er seine Befunde in der Datei und im Bereich „Probleme“ markiert. Aggrega: Show topology graph in der Befehlspalette zeichnet die Komponenten des Release und die Verbindungen zwischen ihnen. Aggrega: Build, Aggrega: Preview build und Aggrega: Pull wirken auf dasselbe Release, und jeder davon ist auch eine Schaltfläche im Bereich Commands der Ansicht Aggrega in der Aktivitätsleiste; Build schreibt seine Dateien in dist/ im Ordner. Aggrega in Visual Studio Code verwenden behandelt den Rest.

Ausführen

Sie bauen das Image mit einem eigenen Dockerfile aus dem Projekt: der Code der Anwendung, mit installiertem Agent Framework und dem deklarativen Agenten darin. Docker Compose führt den eigenen Befehl des Images als Dienst des Agenten aus, da das Recipe keinen festlegt; dieser Befehl muss daher weiterlaufen, und er muss Anfragen bedienen, wenn Sie den Agenten erreichen möchten. Ihr Programm bestimmt die Adresse, die Route und die Antwort.

Der unten gezeigte Lauf verwendete ein solches Image: Python mit den Paketen agent-framework-core, agent-framework-openai und agent-framework-declarative von Agent Framework, eine .NET-Laufzeitumgebung — das Image setzte DOTNET_ROOT auf deren Verzeichnis und DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1 — support-agent.yaml und, als Befehl des Images, einen kleinen eigenen HTTP-Server des Programms auf Port 8000. Der Server lädt den deklarativen Agenten mit AgentFactory(safe_mode=False), sodass dessen =Env.OPENAI_API_KEY den Schlüssel liest, den der Build liefert, und führt den Agenten für jedes POST /ask einmal aus. Bauen Sie Ihr Image im Stammverzeichnis des Projekts, schreiben Sie seinen Namen anstelle von ghcr.io/example/support-agent:1.0.0 in import-answers.yaml und importieren Sie erneut mit --sync, das die neue Antwort in die Entwürfe schreibt und erneut pullt; bauen Sie dann:

Terminal window
docker build -t docs-assistant:local .
aggrega import support-agent.yaml --sync
aggrega build --release release.yaml

Mit docs-assistant:local als Antwort nennt der Sync unter den Zeilen, die er ausgibt, den einen Wert, den er geändert hat:

changed spec.components.supportagent.infra.image in release.yaml

Setzen Sie dann den Schlüssel in Ihrer Shell und starten Sie den Stack:

Terminal window
export OPENAI_API_KEY='your OpenAI key'
docker compose -p docs-assistant -f dist/compose/docker-compose.yaml up -d --wait

-p benennt das Projekt, wie der Ausführungsschritt von Wie ein Import abläuft erklärt.

Testen

Die folgende Anfrage erreicht das Programm, das das Image dieser Anleitung ausführt: den deklarativen Agenten hinter einem kleinen HTTP-Server auf Port 8000, der POST /ask beantwortet. Ihr eigenes Programm bestimmt seine eigene Route und Antwort. Senden Sie sie an http://127.0.0.1:8000, die Adresse, die published_port veröffentlicht, sobald das Programm lauscht, einige Sekunden nach dem Start des Stacks:

Terminal window
curl -sS -X POST http://127.0.0.1:8000/ask -H 'Content-Type: application/json' \
-d '{"question": "In one short sentence: what is Azure Container Apps?"}'
{"error": "the agent failed: ChatClientException: (\"<class 'agent_framework_openai._chat_client.OpenAIChatClient'> service failed to complete the prompt: Error code: 401 - Incorrect API key provided: sk-place************-key. [… omitted: where to find an API key, and the same error repeated as the exception it wraps]"}

Der Lauf setzte OPENAI_API_KEY auf einen Platzhalter, daher ist die Antwort die Ablehnung durch OpenAI, die das Programm weitergibt. Der von OpenAI abgelehnte Schlüssel ist dieser Platzhalter, maskiert angezeigt, also hat =Env.OPENAI_API_KEY des deklarativen Agenten ihn aus der Umgebung gelesen, die der Build liefert.

Beenden Sie den Stack mit:

Terminal window
docker compose -p docs-assistant -f dist/compose/docker-compose.yaml down

Importieren Sie für Kubernetes mit --target helm, übertragen Sie das Image in eine Registry, aus der Ihr Cluster lädt, und nennen Sie es in import-answers.yaml. Erstellen Sie dann das Secret openai-api-key und wenden Sie den Build an, wie der Ausführungsschritt von Wie ein Import abläuft beschreibt. Das Deployment des Agenten hat keinen Service, leiten Sie daher einen lokalen Port an es weiter. Der Befehl läuft, bis Sie ihn beenden:

Terminal window
kubectl port-forward deploy/supportagent 8000:8000
Forwarding from 127.0.0.1:8000 -> 8000
Forwarding from [::1]:8000 -> 8000

Senden Sie von einem anderen Terminal aus dieselbe Anfrage an den weitergeleiteten Port:

Terminal window
curl -sS -X POST http://127.0.0.1:8000/ask -H 'Content-Type: application/json' \
-d '{"question": "In one short sentence: what is Azure Container Apps?"}'
{"error": "the agent failed: ChatClientException: (\"<class 'agent_framework_openai._chat_client.OpenAIChatClient'> service failed to complete the prompt: Error code: 401 - Incorrect API key provided: sk-place************-key. [… omitted: where to find an API key, and the same error repeated as the exception it wraps]"}