building genai applications with golang Download - building genai applications with golang Source Code Download

Titel	Autor	Datum
Entwicklung von Genai -Anwendungen mit Golang	Haimtrann	25/03/2024

Entwicklung von Genai -Anwendungen mit Golang

Einführung

Was wir in der Produktion oft sehen, ist eine Vielzahl von Sprachen, die in Go, Java, .NET geschrieben wurden. Der Großteil des Lernmaterials zum Aufbau von Genai (Generative Artifical Intelligence) Apps ist derzeit derzeit in Python und JavaScript. Dieser Workshop zeigt, wie Sie mit dem Amazon -Grundgestein beginnen, um einige grundlegende Beispiele zu implementieren, ohne Frameworks wie Langchain, Streamlit oder React zu verwenden.

Beispiele sind:

Einfacher Chat und Aufforderung
Einfacher Bildanalysator
Abfragetektordatenbank
Einfache Lag (Abrufer Augmented Generation) Anwendung

Sie werden diese Funktionen nur mit grundlegenden Programmierkonzepten implementieren, ohne einen neuen Rahmen lernen zu müssen, um grundlegende Konzepte wirklich zu verstehen und zu beherrschen.

Stream -Antwort
Nachrichten -API des anthropischen Claude 3 -Modells
Aufforderung an Claude 3 auf Amazon -Grundgestein

Architektur

Bogen

Voraussetzungen

Diese Beispielanwendung geht davon aus, dass Sie bereits eingerichtet sind

Berechtigungen, um Claude 3 Haiku -Modell auf Amazon -Grundgestein aufzurufen
Sie starten eine AWS -Maanged -Wissensbasis
Berechtigungen zum Aufrufen von Amazon OpenSearch Serverless (AOSS) und der verwalteten Wissensbasis

Bitte ersetzen Sie Variablen in /bedrock/constants.go zum Beispiel durch Ihre

 const BEDROCK_REGION = ""
const AOSS_REGION = ""
const KNOWLEDGE_BASE_REGION = ""
const KNOWLEDGE_BASE_ID = ""
const KNOWLEDGE_BASE_MODEL_ID = ""
const KNOWLEDGE_BASE_NUMBER_OF_RESULT = 6
const AOSS_ENDPOINT = ""
const AOSS_NOTE_APP_INDEX_NAME = ""

Anwendung

Projektstruktur

 | - - static
  | - - aoss - index. html
  | -- aoss - query. html
  | -- claude - haiku. html
  | -- image. html
  | -- retrieve. html
  | -- retrieve - generate. html
| -- bedrock
  | -- aoss. go
  | -- bedrock. go
  | -- constants. go
  | -- knowledge - based. go
| -- main. go
| -- go . mod
| -- go . sum

main.go implementieren Sie einen HTTP -Server und eine Routenanforderung an Handler. Bedrock.go und aoss.go sind Funktionen, um Amazon Bedrock und Amazon OpenSearch Serverless (AOSS) aufzurufen. Der statische Ordner enthält ein einfaches Frontend mit JavaScript.

Wichtig

Um AOSS zu verwenden, müssen Sie eine OpenSearch -Sammlung erstellen und ihren URL -Endpunkt in Constants.go bereitstellen. Darüber hinaus müssen Sie den Datenzugriff in der AOSS für die Laufzeitumgebung einrichten (EC2 -Profil, ECS TAKS -Rolle, Lambda -Rolle, .etc).

Wie man rennt

Folgen Sie diesem offiziellen Dokument, um Golang zu installieren, und führen Sie die Anwendung als Folgendes aus

Wichtig

Bitte installieren Sie Go Version 1.21.5

 cd developing - genai - applications - with - golang
go run main . go

Streaming -Antwort

Zunächst ist es gut, einige Datenstrukturen gemäß Amazon Bedrock Claude3 API -Format zu erstellen

 type Content struct {
	Type string `json:"type"`
	Text string `json:"text"`
}

type Message struct {
	Role    string    `json:"role"`
	Content [] Content `json:"content"`
}

type Body struct {
	MaxTokensToSample int       `json:"max_tokens"`
	Temperature       float64   `json:"temperature,omitempty"`
	AnthropicVersion  string    `json:"anthropic_version"`
	Messages          [] Message `json:"messages"`
}

// list of messages
messages := [] Message {{
	Role :    "user" ,
	Content : [] Content {{ Type : "text" , Text : promt }},
}}

// form request body
payload := Body {
	MaxTokensToSample : 2048 ,
	Temperature :       0.9 ,
	AnthropicVersion :  "bedrock-2023-05-31" ,
	Messages :          messages ,
}

Umwandeln Sie die Nutzlast in Bytes und rufen Sie den Grundgestein -Kunden auf

 payload := Body {
	MaxTokensToSample : 2048 ,
	Temperature :       0.9 ,
	AnthropicVersion :  "bedrock-2023-05-31" ,
	Messages :          messages ,
}

// marshal payload to bytes
payloadBytes , err := json . Marshal ( payload )

if err != nil {
	fmt . Println ( err )
	return
}

// create request to bedrock
output , error := BedrockClient . InvokeModelWithResponseStream (
	context . Background (),
	& bedrockruntime. InvokeModelWithResponseStreamInput {
		Body :        payloadBytes ,
		ModelId :     aws . String ( "anthropic.claude-3-haiku-20240307-v1:0" ),
		ContentType : aws . String ( "application/json" ),
		Accept :      aws . String ( "application/json" ),
	},
)

if error != nil {
	fmt . Println ( error )
	return
}

Schließlich analysieren Sie die Streaming -Repräsentation und dekodieren Sie sie in Text. Wenn Sie auf einem HTTP -Server bereitgestellt werden, müssen wir den Code ein wenig ändern, um jeden Anteil der Antwort auf den Client zu streamen. Zum Beispiel hier

 output , error := BedrockClient . InvokeModelWithResponseStream (
	context . Background (),
	& bedrockruntime. InvokeModelWithResponseStreamInput {
		Body :        payloadBytes ,
		ModelId :     aws . String ( "anthropic.claude-3-haiku-20240307-v1:0" ),
		ContentType : aws . String ( "application/json" ),
		Accept :      aws . String ( "application/json" ),
	},
)

if error != nil {
	fmt . Println ( error )
	return
}

// parse response stream
for event := range output . GetStream (). Events () {
	switch v := event .( type ) {
	case * types. ResponseStreamMemberChunk :

		//fmt.Println("payload", string(v.Value.Bytes))

		var resp ResponseClaude3
		err := json . NewDecoder ( bytes . NewReader ( v . Value . Bytes )). Decode ( & resp )
		if err != nil {
			fmt . Println ( err )
		}

		fmt . Println ( resp . Delta . Text )

	case * types. UnknownUnionMember :
		fmt . Println ( "unknown tag:" , v . Tag )

	default :
		fmt . Println ( "union is nil or unknown type" )
	}
}

Einsatz

Dieser Workshop bietet Schritt für Schritt keine detaillierte Bereitstellung der Anwendung. Stattdessen bietet es eine Gesamtarchitektur und eine Bereitstellungsoption. Es ist geradefoward, die Anwendung auf Amazon ECS bereitzustellen.

Bogen

Benutzer stellen eine Frage.
Der Anwendungslastausgleich verteilt die Anfrage an Amazon ECS -Aufgaben.
Die ECS -Aufgaben befragen die Wissensbasis.
Die ECS -Aufgaben empfangen Vektoren und Textbrocken, die für die Frage des Benutzers relevant sind.
Die ECS -Aufgaben bauen und senden die Eingabeaufforderung an das Claude 3 -Modell am Amazon -Grundgestein.
Amazon -Grundgestein strömt die Reaktion auf die ECS -Aufgaben.
Die ECS -Aufgaben streamen die Antwort auf den Anwendungslastausgleich.
Der Anwendungslastausgleich leitet die Antwort an die Benutzer weiter.

Dockerfile

# syntax = docker / dockerfile : 1

# Build the application from source
FROM golang : 1.21 . 5 AS build - stage

WORKDIR / app

COPY go . mod go . sum . /
RUN go mod download

COPY * . go . /
COPY  bedrock . / bedrock

RUN CGO_ENABLED = 0 GOOS = linux go build - o / genaiapp

# Run the tests in the container
FROM build - stage AS run - test - stage

# Deploy the application binary into a lean image
FROM gcr . io / distroless / base - debian11 AS build - release - stage

WORKDIR /

COPY -- from = build - stage / genai - go - app / genaiapp
COPY static . / static

EXPOSE 3000

USER nonroot : nonroot

ENTRYPOINT [ "/genaiapp" ]

ECS -Aufgabenrolle

Die Aufgabenrolle benötigen Berechtigungen an

Rufen Sie Amazon Grundstrock -Laufzeit auf
Rufen Sie die Laufzeit von Amazon Bedrock Agent auf
Zugang zu Claude 3 und Titan -Modellen
Laden Sie Daten in den S3 -Bucket in der Wissensbasis hoch
Zugriff auf die AOSS -Sammlung

Hier ist eine Stichprobe von IAM -Richtlinien, die der Aufgabenrolle beigefügt sind

{
  "Version" : " 2012-10-17 " ,
  "Statement" : [
    {
      "Action" : [
        " bedrock:InvokeModel " ,
        " bedrock:InvokeModelWithResponseStream " ,
        " bedrock:InvokeAgent "
      ],
      "Resource" : [
        " arn:aws:bedrock:<REGION>::foundation-model/anthropic.claude-3-haiku-20240307-v1:0 " ,
        " arn:aws:bedrock:<REGION>::foundation-model/amazon.titan-embed-text-v1 "
      ],
      "Effect" : " Allow "
    },
    {
      "Action" : [ " s3:GetObject " , " s3:PutObject " ],
      "Resource" : [
        " arn:aws:s3:::<BUCKET_NAME> " ,
        " arn:aws:s3:::<BUCKET_NAME>/* "
      ],
      "Effect" : " Allow "
    },
    {
      "Action" : " aoss:APIAccessAll " ,
      "Resource" : [
        " arn:aws:aoss:<REGION>:<ACCOUNT_ID>:collection/<COLLECTION_ID> "
      ],
      "Effect" : " Allow "
    }
  ]
}