Zu Beginn des Jahres 2026 verfügt AWS über mehrere verwandte, aber unterschiedliche Komponenten, aus denen seine Agenten- und LLM-Abstraktionen bestehen.

• Grundgestein ist die Modellschicht, die den Zugriff auf große Sprachmodelle ermöglicht.
• Agenten für Bedrock ist die verwaltete Anwendungsschicht. Mit anderen Worten: AWS führt die Agenten entsprechend Ihren Anforderungen für Sie aus.
• Bedrock AgentCore ist eine Infrastrukturschicht, die es AWS ermöglicht, Agenten auszuführen, die Sie mithilfe von Drittanbieter-Frameworks wie CrewAI und LangGraph entwickeln.

Abgesehen von diesen drei Diensten bietet AWS auch Folgendes an Stränge, eine Open-Supply-Python-Bibliothek zum Erstellen von Agenten außerhalb des Bedrock-Dienstes, die dann auf anderen AWS-Diensten wie ECS und Lambda bereitgestellt werden kann.

Es kann verwirrend sein, weil alle drei agentenbasierten Dienste den Begriff „Bedrock“ im Namen tragen, aber in diesem Artikel werde ich mich auf den Normal-Bedrock-Dienst konzentrieren und zeigen, wie und warum Sie ihn verwenden würden. Normal-Bedrock-Service und zeigen Sie, wie und warum Sie ihn nutzen würden.

Als Service ist Bedrock erst seit Anfang 2023 auf AWS verfügbar. Das sollte Ihnen einen Hinweis darauf geben, warum es eingeführt wurde. Amazon konnte den Aufstieg großer Sprachmodelle und deren Auswirkungen auf die IT-Architektur und den Systementwicklungsprozess deutlich erkennen. Das sind Fleisch und Kartoffeln von AWS, und sie wollten, dass niemand ihr Mittagessen isst.

Und obwohl AWS einige eigene LLMs entwickelt hat, wurde ihm klar, dass es, um wettbewerbsfähig zu bleiben, den Benutzern die allerbesten Modelle, wie die von Anthropic, zur Verfügung stellen muss. Und hier kommt Bedrock ins Spiel. Wie sie in ihrem eigenen Klappentext auf ihrer Web site sagten:

… Bedrock ist ein vollständig verwalteter Dienst, der über eine einzige API eine Auswahl an leistungsstarken Basis-Modellen (FMs) von führenden KI-Unternehmen wie AI21 Labs, Anthropic, Cohere, Meta, Stability AI und Amazon sowie eine breite Palette an Funktionen bietet, die Sie zum Erstellen generativer KI-Anwendungen benötigen, um die Entwicklung zu vereinfachen und gleichzeitig Datenschutz und Sicherheit zu gewährleisten.

Wie greife ich auf Bedrock zu?

Okay, das ist die Theorie hinter dem Warum von Bedrock, aber wie bekommen wir Zugang dazu und können es tatsächlich nutzen? Es überrascht nicht, dass Sie als Erstes ein AWS-Konto benötigen. Ich gehe davon aus, dass Sie dies bereits haben. Wenn nicht, klicken Sie auf den folgenden Hyperlink, um eines einzurichten.

https://aws.amazon.com/account

Praktischerweise fällt nach der Registrierung für ein neues AWS-Konto ein Großteil der von Ihnen genutzten Dienste unter das sogenannte „kostenlose Kontingent“ bei AWS, was bedeutet, dass Ihre Kosten minimal sein sollten ein Jahr nach der Erstellung Ihres Kontos – vorausgesetzt, Sie werden nicht verrückt und starten riesige Rechenserver und dergleichen.

Es gibt drei Hauptmöglichkeiten, AWS-Dienste zu nutzen.

• Über die Konsole. Wenn Sie ein Anfänger sind, wird dies wahrscheinlich Ihre bevorzugte Route sein, da dies der einfachste Einstieg ist
• Über eine API. Wenn Sie sich mit Programmieren auskennen, können Sie über eine API auf alle Dienste von AWS zugreifen. Für Python-Programmierer stellt AWS beispielsweise Folgendes bereit boto3 Bibliothek. Es gibt ähnliche Bibliotheken für andere Sprachen wie JavaScript usw.
• Über die Befehlszeilenschnittstelle (CLI). Die CLI ist ein zusätzliches Software, das Sie von AWS herunterladen können und das Ihnen die Interaktion mit AWS-Diensten direkt von Ihrem Terminal aus ermöglicht.

Beachten Sie, dass Sie zur Verwendung der beiden letztgenannten Methoden Anmeldeinformationen auf Ihrem lokalen System eingerichtet haben sollten.

Was kann ich mit Bedrock machen?

Die kurze Antwort ist, dass Sie die meisten Dinge, die Sie können, mit regulären Chat-Modellen von OpenAI, Anthropic, Google usw. tun können. Bedrock liegt eine Reihe von Fundamentmodellen zugrunde, die Sie damit verwenden können, wie zum Beispiel:

• Kimi K2 Denken. Ein tiefes Argumentationsmodell
• Claude Opus 4.5. Für viele Menschen ist dies der beste LLM, der bisher verfügbar ist.
• GPT-OSS. OpenAIs Open-Supply-LLM

Und viele, viele andere darüber hinaus. Eine vollständige Liste finden Sie unter dem folgenden Hyperlink.

https://aws.amazon.com/bedrock/model-choice

Wie verwende ich Bedrock?

Um Bedrock zu verwenden, verwenden wir eine Mischung aus der AWS CLI und der Python-API, die von der boto3-Bibliothek bereitgestellt wird. Stellen Sie sicher, dass Sie die folgende Einrichtung als Voraussetzung haben

• Ein AWS-Konto.
• Die AWS CLI wurde heruntergeladen und auf Ihrem System installiert.
• Ein IAM-Benutzer (Identification and Entry Administration) wird mit den entsprechenden Berechtigungen und Zugriffsschlüsseln eingerichtet. Sie können dies über die AWS-Konsole tun.
• Konfigurieren Sie Ihre Benutzeranmeldeinformationen über die AWS CLI wie folgt. Im Allgemeinen müssen drei Informationen bereitgestellt werden. All das erhalten Sie aus dem vorherigen Schritt oben. Sie werden aufgefordert, relevante Informationen einzugeben.

$ aws configure

AWS Entry Key ID (None): AKIAIOSFODNN7EXAMPLE
AWS Secret Entry Key (None): wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default area identify (None): us-west-2
Default output format (None):

Gewähren von Bedrock-Zugriff auf ein Modell

Früher (vor ein paar Monaten!) musste man die AWS-Verwaltungskonsole verwenden, um Zugriff auf bestimmte Modelle von Bedrock anzufordern, aber jetzt wird der Zugriff automatisch gewährt, wenn man ein Modell zum ersten Mal aufruft.

Beachten Sie, dass Erstbenutzer bei Anthropic-Modellen möglicherweise Anwendungsfalldetails übermitteln müssen, bevor sie auf das Modell zugreifen können. Beachten Sie auch den Zugriff auf Prime-Modelle von Anthropic und anderen Anbietern WilleKosten entstehen Stellen Sie daher bitte sicher, dass Sie Ihre Abrechnung regelmäßig überwachen und alle Modellzugänge entfernen, die Sie nicht mehr benötigen.

Allerdings müssen wir noch den Modellnamen kennen, den wir verwenden möchten. Um eine Liste aller Bedrock-kompatiblen Modelle zu erhalten, können wir den folgenden AWS CLI-Befehl verwenden.

aws bedrock list-foundation-models

Dadurch wird ein JSON-Ergebnissatz zurückgegeben, der verschiedene Eigenschaften jedes Modells auflistet, etwa so.

{
    "modelSummaries": (
        {
            "modelArn": "arn:aws:bedrock:us-east-2::foundation-model/nvidia.nemotron-nano-12b-v2",
            "modelId": "nvidia.nemotron-nano-12b-v2",
            "modelName": "NVIDIA Nemotron Nano 12B v2 VL BF16",
            "providerName": "NVIDIA",
            "inputModalities": (
                "TEXT",
                "IMAGE"
            ),
            "outputModalities": (
                "TEXT"
            ),
            "responseStreamingSupported": true,
            "customizationsSupported": (),
            "inferenceTypesSupported": (
                "ON_DEMAND"
            ),
            "modelLifecycle": {
                "standing": "ACTIVE"
            }
        },
        {
            "modelArn": "arn:aws:bedrock:us-east-2::foundation-model/anthropic.claude-sonnet-4-20250514-v1:0",
...
...
...

Wählen Sie das gewünschte Modell aus und notieren Sie es Modell-ID aus der JSON-Ausgabe, da wir diese später in unserem Python-Code benötigen. Ein wichtiger Vorbehalt hierbei ist, dass Sie in einer Modellbeschreibung häufig Folgendes sehen:

...
...
"inferenceTypesSupported": (
    "INFERENCE_PROFILE"
)
...
...

Dies ist Modellen vorbehalten, die:

• Sind groß oder sehr gefragt
• Erfordern reservierte oder verwaltete Kapazität
• Erfordert explizite Kosten- und Durchsatzkontrollen

Für diese Modelle können wir in unserem Code nicht einfach auf die Modell-ID verweisen. Stattdessen müssen wir auf eine verweisen Inferenzprofil. Ein Inferenzprofil ist eine Bedrock-Ressource, die an ein oder mehrere grundlegende LLMs und eine Area gebunden ist.

Es gibt zwei Möglichkeiten, ein Inferenzprofil zu erhalten, das Sie verwenden können. Die erste besteht darin, selbst eines zu erstellen. Diese werden Anwendungsprofile genannt. Die zweite Möglichkeit besteht darin, eines der von AWS unterstützten Profile zu verwenden. Dies ist die einfachere Choice, da sie für Sie vorgefertigt ist und Sie lediglich die relevante Profil-ID abrufen müssen, die mit dem Inferenzprofil verknüpft ist, um es in Ihrem Code zu verwenden.

Wenn Sie Ihr Anwendungsprofil erstellen möchten, sehen Sie sich die entsprechende AWS-Dokumentation an, aber ich werde in meinem Beispielcode ein unterstütztes Profil verwenden.

Eine Liste der unterstützten Profile in AWS finden Sie unter dem folgenden Hyperlink:

https://docs.aws.amazon.com/bedrock/newest/userguide/inference-profiles-support.html#inference-profiles-support-system

Für mein erstes Codebeispiel möchte ich Claudes Sonnet 3.5 V2-Modell verwenden, additionally habe ich auf die Zeile oben geklickt und die folgende Beschreibung gesehen.

Ich habe mir die Profil-ID ( us.anthropic.claude-3–5-sonnet-20241022-v2:0 ) und eine der gültigen Quellregionen ( us-east-1 ) notiert.

Für meine zweiten beiden Beispielcodeausschnitte verwende ich OpenAIs Open-Supply-LLM für die Textausgabe und den Titan Picture Generator von AWS für Bilder. Für keines dieser Modelle ist ein Inferenzprofil erforderlich. Sie können daher einfach die reguläre Modell-ID für sie in Ihrem Code verwenden.

Hinweis: Unabhängig davon, für welches Modell Sie sich entscheiden, stellen Sie sicher, dass Ihre AWS-Area für jedes Modell auf den richtigen Wert eingestellt ist.

Einrichten einer Entwicklungsumgebung

Da wir etwas programmieren werden, ist es am besten, Ihre Umgebung zu isolieren, damit wir keine unserer anderen Projekte beeinträchtigen. Additionally lasst uns das jetzt tun. Ich verwende dafür Home windows und den UV-Paketmanager, verwende aber das Software, mit dem du am besten zurechtkommst. Mein Code wird in einem Jupyter-Pocket book ausgeführt.

uv init bedrock_demo --python 3.13
cd bedrock_demo
uv add boto3 jupyter

# To run the pocket book, sort this in
uv run jupyter pocket book

Verwendung von Bedrock aus Python

Sehen wir uns Bedrock anhand einiger Beispiele in Aktion an. Das erste wird einfach sein, und wir werden die Komplexität im Laufe der Zeit schrittweise erhöhen.

Beispiel 1: Eine einfache Frage und Antwort unter Verwendung eines Inferenzprofils

In diesem Beispiel wird das Modell Claude Sonnet 3.5 V2 verwendet, über das wir zuvor gesprochen haben. Wie bereits erwähnt, verwenden wir zum Aufrufen dieses Modells eine Profil-ID, die seinem Inferenzprofil zugeordnet ist.

import json
import boto3

brt = boto3.shopper("bedrock-runtime", region_name="us-east-1")

profile_id = "us.anthropic.claude-3-5-sonnet-20241022-v2:0"

physique = json.dumps({
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 200,
    "temperature": 0.2,
    "messages": (
        {
            "function": "person",
            "content material": (
                {"sort": "textual content", "textual content": "What's the capital of France?"}
            )
        }
    )
})

resp = brt.invoke_model(
    modelId=profile_id,
    physique=physique,
    settle for="software/json",
    contentType="software/json"
)

information = json.hundreds(resp("physique").learn())

# Claude responses come again as a "content material" array, not OpenAI "selections"
print(information("content material")(0)("textual content"))

#
# Output
#
The capital of France is Paris.

Beachten Sie, dass durch den Aufruf dieses Modells (und ähnlicher Modelle) ein implizites Abonnement zwischen Ihnen und dem AWS-Marktplatz entsteht. Das ist nicht eine wiederkehrende regelmäßige Gebühr. Es fallen nur dann Kosten an, wenn das Modell tatsächlich genutzt wird. Es ist jedoch am besten, dies im Auge zu behalten, um unerwartete Rechnungen zu vermeiden. Sie sollten eine E-Mail mit einem Überblick über die Abonnementvereinbarung sowie einen Hyperlink zum Verwalten und/oder Kündigen bestehender eingerichteter Modellabonnements erhalten.

Beispiel 2: Erstellen Sie ein Bild

Eine einfache Picture-Erstellung mit dem AWS-eigenen Titan-Modell. Dieses Modell ist keinem Inferenzprofil zugeordnet, daher können wir es einfach über seine Modell-ID referenzieren.

import json
import base64
import boto3

brt_img = boto3.shopper("bedrock-runtime", region_name="us-east-1")
model_id_img = "amazon.titan-image-generator-v2:0"

immediate = "A hippo using a motorbike."

physique = json.dumps({
    "taskType": "TEXT_IMAGE",
    "textToImageParams": {
        "textual content": immediate
    },
    "imageGenerationConfig": {
        "numberOfImages": 1,
        "top": 1024,
        "width": 1024,
        "cfgScale": 7.0,
        "seed": 0
    }
})

resp = brt_img.invoke_model(
    modelId=model_id_img,
    physique=physique,
    settle for="software/json",
    contentType="software/json"
)

information = json.hundreds(resp("physique").learn())

# Titan returns base64-encoded pictures within the "pictures" array
img_b64 = information("pictures")(0)
img_bytes = base64.b64decode(img_b64)

out_path = "titan_output.png"
with open(out_path, "wb") as f:
    f.write(img_bytes)

print("Saved:", out_path)

Auf meinem System sah das Ausgabebild so aus.

Beispiel 3: Ein Triage-Assistent für den technischen Help, der das OSS-Modell von OpenAI verwendet

Dies ist ein komplexeres und nützlicheres Beispiel. Hier richten wir einen Assistenten ein, der von technisch nicht versierten Benutzern gemeldete Probleme aufnimmt und zusätzliche Fragen ausgibt, die der Benutzer möglicherweise beantworten soll, sowie die wahrscheinlichsten Ursachen des Issues und die weiteren Schritte, die ergriffen werden müssen. Wie unser vorheriges Beispiel ist dieses Modell nicht mit einem Inferenzprofil verknüpft.

import json
import re
import boto3
from pydantic import BaseModel, Discipline
from typing import Listing, Literal, Optionally available

# ----------------------------
# Bedrock setup
# ----------------------------
REGION = "us-east-2"
MODEL_ID = "openai.gpt-oss-120b-1:0"

brt = boto3.shopper("bedrock-runtime", region_name=REGION)

# ----------------------------
# Output schema
# ----------------------------
Severity = Literal("low", "medium", "excessive")
Class = Literal("account", "billing", "system", "community", "software program", "safety", "different")

class TriageResponse(BaseModel):
    class: Class
    severity: Severity
    abstract: str = Discipline(description="One-sentence restatement of the issue.")
    likely_causes: Listing(str) = Discipline(description="Prime believable causes, concise.")
    clarifying_questions: Listing(str) = Discipline(description="Ask solely what is required to proceed.")
    safe_next_steps: Listing(str) = Discipline(description="Step-by-step actions secure for a non-technical person.")
    stop_and_escalate_if: Listing(str) = Discipline(description="Clear crimson flags that require an expert/helpdesk.")
    recommended_escalation_target: Optionally available(str) = Discipline(
        default=None,
        description="If severity is excessive, who to contact (e.g., IT admin, financial institution, ISP)."
    )

# ----------------------------
# Helpers
# ----------------------------
def invoke_chat(messages, max_tokens=800, temperature=0.2) -> dict:
    physique = json.dumps({
        "messages": messages,
        "max_tokens": max_tokens,
        "temperature": temperature
    })

    resp = brt.invoke_model(
        modelId=MODEL_ID,
        physique=physique,
        settle for="software/json",
        contentType="software/json"
    )
    return json.hundreds(resp("physique").learn())

def extract_content(information: dict) -> str:
    return information("selections")(0)("message")("content material")

def extract_json_object(textual content: str) -> dict:
    """
    Extract the primary JSON object from mannequin output.
    Handles widespread instances like <reasoning> blocks or additional textual content.
    """
    textual content = re.sub(r"<reasoning>.*?</reasoning>", "", textual content, flags=re.DOTALL).strip()

    begin = textual content.discover("{")
    if begin == -1:
        elevate ValueError("No JSON object discovered.")

    depth = 0
    for i in vary(begin, len(textual content)):
        if textual content(i) == "{":
            depth += 1
        elif textual content(i) == "}":
            depth -= 1
            if depth == 0:
                return json.hundreds(textual content(begin:i+1))

    elevate ValueError("Unbalanced JSON braces; couldn't parse.")

# ----------------------------
# The helpful operate
# ----------------------------
def triage_issue(user_problem: str) -> TriageResponse:
    messages = (
        {
            "function": "system",
            "content material": (
                "You're a cautious technical help triage assistant for non-technical customers. "
                "You have to be conservative and safety-first. "
                "Return ONLY legitimate JSON matching the given schema. No additional textual content."
            )
        },
        {
            "function": "person",
            "content material": f"""
Consumer drawback:
{user_problem}

Return JSON that matches this schema:
{TriageResponse.model_json_schema()}
""".strip()
        }
    )

    uncooked = invoke_chat(messages)
    textual content = extract_content(uncooked)
    parsed = extract_json_object(textual content)
    return TriageResponse.model_validate(parsed)

# ----------------------------
# Instance
# ----------------------------
if __name__ == "__main__":
    drawback = "My laptop computer is related to Wi-Fi however web sites will not load, and Zoom retains saying unstable connection."
    outcome = triage_issue(drawback)
    print(outcome.model_dump_json(indent=2))

Hier ist die Ausgabe.

"class": "community",
  "severity": "medium",
  "abstract": "Laptop computer reveals Wi‑Fi connection however can't load web sites and Zoom 
              experiences an unstable connection.",
  "likely_causes": (
    "Router or modem malfunction",
    "DNS decision failure",
    "Native Wi‑Fi interference or weak sign",
    "IP handle battle on the community",
    "Firewall or safety software program blocking site visitors",
    "ISP outage or throttling"
  ),
  "clarifying_questions": (
    "Are different units on the identical Wi‑Fi community in a position to entry the web?",
    "Did the issue begin after any latest adjustments (e.g., new software program, OS replace, VPN set up)?",
    "Have you ever tried shifting nearer to the router or utilizing a wired Ethernet connection?",
    "Do you see any error codes or messages within the browser or Zoom moreover "unstable connection"?"
  ),
  "safe_next_steps": (
    "Restart the router and modem by unplugging them for 30 seconds, then energy them again on.",
    "On the laptop computer, neglect the Wi‑Fi community, then reconnect and re-enter the password.",
    "Run the constructed‑in Home windows community troubleshooter (Settings → Community & Web → Standing → Community troubleshooter).",
    "Disable any VPN or proxy quickly and check the connection once more.",
    "Open a command immediate and run `ipconfig /launch` adopted by `ipconfig /renew`.",
    "Flush the DNS cache with `ipconfig /flushdns`.",
    "Strive accessing a easy web site (e.g., http://instance.com) and be aware if it hundreds.",
    "If attainable, join the laptop computer to the router through Ethernet to see if the problem persists."
  ),
  "stop_and_escalate_if": (
    "The laptop computer nonetheless can't attain any web site after finishing all steps.",
    "Different units on the identical community additionally can't entry the web.",
    "You obtain error messages indicating {hardware} failure (e.g., Wi‑Fi adapter not discovered).",
    "The router repeatedly restarts or reveals error lights.",
    "Zoom continues to report a poor or unstable connection regardless of a working web check."
  ),
  "recommended_escalation_target": "IT admin"
}

Zusammenfassung

Dieser Artikel wurde vorgestellt AWS-Grundgestein, Das von AWS verwaltete Gateway zu grundlegenden großen Sprachmodellen erklärt, warum es existiert und wie es in das Gesamtbild passt AWS AI Stack und wie man ihn in der Praxis nutzt. Wir haben die Modellerkennung, die Einrichtung von Regionen und Anmeldeinformationen sowie den Hauptunterschied zwischen On-Demand-Modellen und solchen, die Inferenzprofile erfordern – eine häufige Quelle der Verwirrung für Entwickler – behandelt.

Anhand praktischer Python-Beispiele haben wir die Textual content- und Bildgenerierung sowohl mit standardmäßigen On-Demand-Modellen als auch mit solchen, die ein Inferenzprofil erfordern, demonstriert.

Im Kern spiegelt Bedrock die langjährige Philosophie von AWS wider: die Komplexität der Infrastruktur zu abstrahieren, ohne die Kontrolle zu verlieren. Anstatt ein einzelnes „bestes“ Modell voranzutreiben, behandelt Bedrock Basis-Modelle als verwaltete Infrastrukturkomponenten – austauschbar, steuerbar und regional orientiert. Dies deutet auf eine Zukunft hin, in der sich Bedrock weniger als Chat-Schnittstelle, sondern mehr als Modellorchestrierungsschicht entwickelt, die eng mit IAM, Netzwerken, Kostenkontrollen und Agenten-Frameworks integriert ist.

Im Laufe der Zeit können wir davon ausgehen, dass sich Bedrock weiter in Richtung standardisierter Inferenzverträge (Abonnements) und einer klareren Trennung zwischen Experimentier- und Produktionskapazität bewegt. Und mit ihren Agent- und AgentCore-Diensten sehen wir bereits eine tiefere Integration von Agenten-Workflows mit Bedrock, wodurch Modelle nicht als eigenständige Produkte, sondern als dauerhafte Bausteine ​​innerhalb von AWS-Systemen positioniert werden.

---

Zur Klarstellung: Abgesehen davon, dass ich gelegentlich deren Dienste nutze, habe ich keine Verbindung oder Zugehörigkeit zu Amazon Net Companies

Erinnern Sie sich an die Zeiten, als die Klassifizierung von Texten bedeutete, sich auf eine Reise durch maschinelles Lernen zu begeben? Wenn Sie schon lange genug im ML-Bereich tätig sind, haben Sie wahrscheinlich miterlebt, wie mindestens ein Crew bei der Entwicklung des „perfekten“ Textklassifizierungssystems verschwunden ist. Die Geschichte geht normalerweise ungefähr so:

• Monat 1: „Wir trainieren einfach schnell ein NLP-Modell!“
• Monat 2: „Wir brauchen mehr Trainingsdaten…“
• Monat 3: „Das ist intestine genug“

Seit Jahren gehört die Textklassifizierung zum Bereich des klassischen ML. Ich erinnere mich, dass ich zu Beginn meiner Karriere eine Help-Vektor-Maschine (SVM) für die E-Mail-Klassifizierung trainiert habe. Viel Vorverarbeitung, Iteration, Datenerfassung und Beschriftung.

Aber hier ist die Wendung: Wir schreiben das Jahr 2024 und generative KI-Modelle können es schaffen „allgemein“ Klassifizieren Sie Texte über den Tellerrand hinaus! Sie können ein robustes Ticketklassifizierungssystem erstellen, ohne Tausende von gekennzeichneten Trainingsbeispielen zu sammeln, ML-Trainingspipelines zu verwalten oder benutzerdefinierte Modelle zu pflegen.

In diesem Beitrag erfahren Sie, wie Sie ein Jira-Ticketklassifizierungssystem mithilfe großer Sprachmodelle auf Amazon Bedrock und anderen AWS-Diensten einrichten.

HAFTUNGSAUSSCHLUSS: Ich bin GenAI-Architekt bei AWS und meine Meinung ist meine eigene.

Warum Jira-Tickets klassifizieren?

Eine häufige Frage von Unternehmen ist, zu verstehen, wie Groups ihre Zeit verbringen. Jira verfügt über Tagging-Funktionen, die jedoch manchmal aufgrund menschlicher Fehler oder mangelnder Granularität unzureichend sind. Durch diese Übung erhalten Unternehmen bessere Einblicke in die Aktivitäten ihres Groups und können so datengesteuerte Entscheidungen über Ressourcenzuweisung, Projektinvestitionen und Abschreibungen treffen.

Warum nicht andere NLP-Ansätze nutzen?

Herkömmliche ML-Modelle und kleinere Transformatoren wie BERT benötigen Hunderte (oder Tausende) beschrifteter Beispiele, während LLMs Textual content sofort klassifizieren können. In unseren Jira-Ticketklassifizierungstests erreichte oder übertraf ein Immediate-Engineering-Ansatz herkömmliche ML-Modelle und verarbeitete mehr als 10.000 Jahrestickets für etwa 10 US-Greenback professional Jahr mit Claude Haiku (ohne andere AWS-Servicekosten). Außerdem lassen sich Eingabeaufforderungen einfacher aktualisieren als Modelle neu trainieren.

Das Github-Repo enthält eine Beispielanwendung, die eine Verbindung zu Jira Cloud herstellt, Tickets klassifiziert und sie in einem Format ausgibt, das von Ihrem bevorzugten Dashboarding-Software (Tableu, Quicksight oder einem anderen Software, das CSVs unterstützt) verwendet werden kann.

Wichtiger Hinweis: Dieses Projekt stellt Ressourcen in Ihrer AWS-Umgebung mithilfe von Terraform bereit. Es fallen Kosten für die genutzten AWS-Ressourcen an. Bitte beachten Sie die Preise für Dienste wie Lambda, Bedrock, Glue und S3 in Ihrer AWS-Area.

Voraussetzungen

In der Umgebung, in der Sie diesen Code bereitstellen möchten, müssen Terraform und AWS CLI installiert sein

Die Architektur ist ziemlich geradlinig. Particulars finden Sie weiter unten.

Schritt 1: Eine AWS Lambda-Funktion wird auf einem Cron-Job ausgelöst, um Jira-Tickets basierend auf einem Zeitfenster abzurufen. Diese Tickets werden dann formatiert und in einen S3-Bucket darunter verschoben /unbearbeitet Präfix.

Schritt 2: Ein Klebeauftrag wird ausgelöst /unbearbeitet Objekt setzt. Dadurch wird eine PySpark-Deduplizierungsaufgabe ausgeführt, um sicherzustellen, dass keine doppelten Tickets in das Dashboard gelangen. Die deduplizierten Tickets werden dann an den gesendet /inszeniert Präfix. Dies ist nützlich, wenn Sie Tickets manuell hochladen und sich auf den automatischen Abruf verlassen. Wenn Sie sicherstellen können, dass keine Duplikate vorhanden sind, können Sie diesen Schritt entfernen.

Schritt 3: Für die neuen Tickets wird eine Klassifizierungsaufgabe gestartet, indem Amazon Bedrock aufgerufen wird, die Tickets basierend auf einer Eingabeaufforderung für ein großes Sprachmodell (LLM) zu klassifizieren. Nach der Klassifizierung werden die fertigen Ergebnisse an die weitergeleitet /verarbeitet Präfix. Von hier aus können Sie die verarbeitete CSV-Datei mit einem beliebigen Dashboarding-Software abrufen, das eine CSV-Datei verarbeiten kann.

Klonen Sie zunächst das Github-Repo oben und verschieben Sie es in das Verzeichnis /terraform

$ git clone https://github.com/aws-samples/jira-ticket-classification.git
$ cd jira-ticket-classification/terraform

Führen Sie Terraform Init aus, planen Sie es und wenden Sie es an. Stellen Sie sicher, dass Terraform auf Ihrem Laptop installiert und die AWS CLI konfiguriert ist.

$ terraform init
$ terraform plan
$ terraform apply

Sobald die Infrastruktur in Ihrem Konto bereitgestellt ist, können Sie zum AWS Secrets and techniques Supervisor navigieren und das Geheimnis mit Ihren Jira Cloud-Anmeldeinformationen aktualisieren. Sie benötigen einen API-Schlüssel, eine Foundation-URL und eine E-Mail-Adresse, um den automatischen Pull zu aktivieren

Und das ist es!

Sie können (1) warten, bis der Cron einen automatischen Abruf startet, (2) die Tickets in CSV exportieren und in das S3-Bucket-Präfix /unprocessed hochladen oder (3) die Lambda-Funktion mithilfe eines Exams manuell auslösen.

Jira-Abruf:

Jira fetch verwendet eine Lambda-Funktion mit einem Cloudwatch-Cron-Ereignis, um es auszulösen. Der Lambda ruft das AWS Secret ab und verwendet eine Get-Anfrage in einer Whereas-Schleife, um paginierte Ergebnisse abzurufen, bis die JQL-Abfrage abgeschlossen ist:

def fetch_jira_issues(base_url, project_id, e-mail, api_key):
url = f"{base_url}/relaxation/api/3/search"
# Calculate the date 8 days in the past
eight_days_ago = (datetime.now() - timedelta(days=8)).strftime("%Y-%m-%d")
# Create JQL
jql = f"mission = {project_id} AND created >= '{eight_days_ago}' ORDER BY created DESC"
# Move into params of request.
params = {
"jql": jql,
"startAt": 0
}
all_issues = ()
auth = HTTPBasicAuth(e-mail, api_key)
headers = {"Settle for": "utility/json"}
whereas True:
response = requests.get(url, headers=headers, params=params, auth=auth)
if response.status_code != 200:
increase Exception(f"Didn't fetch points for mission {project_id}: {response.textual content}")
information = json.hundreds(response.textual content)
points = information('points')
all_issues.lengthen(points)
if len(all_issues) >= information('complete'):
break
params('startAt') = len(all_issues)
return all_issues

Anschließend wird eine Zeichenfolgendarstellung einer CSV erstellt und in S3 hochgeladen:

def upload_to_s3(csv_string, bucket, key):
attempt:
s3_client.put_object(
Bucket=bucket,
Key=key,
Physique=csv_string,
ContentType='textual content/csv'
)
besides Exception as e:
increase Exception(f"Didn't add CSV to S3: {str(e)}")

Klebeauftrag

Ein S3-Ereignis im Präfix /unprocessed löst ein zweites Lambda aus, das einen AWS Glue-Auftrag startet. Dies ist nützlich, wenn es mehrere Einstiegspunkte gibt, über die Jira-Tickets in das System gelangen können. Zum Beispiel, wenn Sie eine Auffüllung durchführen möchten.

import boto3 
# Initialize Boto3 Glue shopper
glue_client = boto3.shopper('glue')
def handler(occasion, context):
# Print occasion for debugging
print(f"Acquired occasion: {json.dumps(occasion)}")
# Get bucket identify and object key (file identify) from the S3 occasion
attempt:
s3_event = occasion('Data')(0)('s3')
s3_bucket = s3_event('bucket')('identify')
s3_key = s3_event('object')('key')
besides KeyError as e:
print(f"Error parsing S3 occasion: {str(e)}")
increase
response = glue_client.start_job_run(
JobName=glue_job_name,
Arguments={
'--S3_BUCKET': s3_bucket,
'--NEW_CSV_FILE': s3_key
}
)

Der Glue-Job selbst ist in PySpark geschrieben und im Code-Repo zu finden Hier. Die wichtige Erkenntnis ist, dass es Folgendes tut: linksanti Treten Sie bei, indem Sie die Drawback-IDs der Elemente in der neuen CSV-Datei mit allen IDs in den /staged-CSVs vergleichen.

Die Ergebnisse werden dann an die weitergeleitet /inszeniert Präfix.

Jira-Tickets klassifizieren:

Hier wird es interessant. Wie sich herausstellt, kann der Einsatz von Immediate Engineering eine gleichwertige, wenn nicht sogar bessere Leistung erbringen als ein Textklassifizierungsmodell, das einige Techniken verwendet.

• Sie können die Klassifizierungen und ihre Beschreibungen in einer Eingabeaufforderung definieren.
• Bitten Sie das Modell, Schritt für Schritt zu denken (Gedankenkette).
• Und dann die Klassifizierung ausgeben, ohne ein einziges Modell trainieren zu müssen. Sehen Sie sich die Eingabeaufforderung unten an:

Notiz: Es ist wichtig, Ihre Eingabeaufforderung mithilfe einer von Menschen kuratierten Teilmenge klassifizierter/beschrifteter Tickets zu validieren. Sie sollten diese Eingabeaufforderung über den Validierungsdatensatz ausführen, um sicherzustellen, dass sie mit der erwarteten Klassifizierung der Tickets übereinstimmt

SYSTEM_PROMPT = '''
You're a help ticket assistant. You're given fields of a Jira ticket and your activity is to categorise the ticket primarily based on these fields
Under is the record of potential classifications together with descriptions of these classifications.
<classifications>
ACCESS_PERMISSIONS_REQUEST: Used when somebody does not have the write permissions or cannot log in to one thing or they cannot get the right IAM credentials to make a service work.
BUG_FIXING: Used when one thing is failing or a bug is discovered. Usually instances the descriptions embody logs or technical data.
CREATING_UPDATING_OR_DEPRECATING_DOCUMENTATION: Used when documentation is old-fashioned. Often references documentation within the textual content.
MINOR_REQUEST: That is not often used. Often a bug repair however it's very minor. If it appears even remotely difficult use BUG_FIXING.
SUPPORT_TROUBLESHOOTING: Used when asking for help for some engineering occasion. May appear to be an automatic ticket.
NEW_FEATURE_WORK: Often describes a brand new characteristic ask or one thing that is not operational.
</classifications>
The fields accessible and their descriptions are beneath.
<fields>
Summmary: It is a abstract or title of the ticket
Description: The outline of the difficulty in pure language. Nearly all of context wanted to categorise the textual content will come from this discipline
</fields>
<guidelines>
* It's attainable that some fields could also be empty through which case ignore them when classifying the ticket
* Assume by your reasoning earlier than making the classification and place your thought course of in <pondering></pondering> tags. That is your house to suppose and purpose in regards to the ticket classificaiton.
* Upon getting completed pondering, classify the ticket utilizing ONLY the classifications listed above and place it in <reply></reply> tags.
</guidelines>'''
USER_PROMPT = '''
Utilizing solely the ticket fields beneath:
<summary_field>
{abstract}
</summary_field>
<description_field>
{description}
</description_field>
Classify the ticket utilizing ONLY 1 of the classifications listed within the system immediate. Keep in mind to suppose step-by-step earlier than classifying the ticket and place your ideas in <pondering></pondering> tags.
If you find yourself completed pondering, classify the ticket and place your reply in <reply></reply> tags. ONLY place the classifaction within the reply tags. Nothing else.
'''

Wir haben eine Hilfsklasse hinzugefügt, die die Aufrufe an Bedrock weiterleitet, um die Sache zu beschleunigen:

import boto3
from concurrent.futures import ThreadPoolExecutor, as_completed
import re
from typing import Record, Dict
from prompts import USER_PROMPT, SYSTEM_PROMPT

class TicketClassifier:
SONNET_ID = "anthropic.claude-3-sonnet-20240229-v1:0"
HAIKU_ID = "anthropic.claude-3-haiku-20240307-v1:0"
HYPER_PARAMS = {"temperature": 0.35, "topP": .3}
REASONING_PATTERN = r'<pondering>(.*?)</pondering>'
CORRECTNESS_PATTERN = r'<reply>(.*?)</reply>'
def __init__(self):
self.bedrock = boto3.shopper('bedrock-runtime')
def classify_tickets(self, tickets: Record(Dict(str, str))) -> Record(Dict(str, str)):
prompts = (self._create_chat_payload


[ad_2]
]]>
					
					http://chatgpz.de/machine-learning/klassifizieren-sie-jira-tickets-mit-genai-auf-amazon-bedrock-von-tanner-mcrae-november-2024/feed/
			0
		
		
		4971