building genai applications with golang

titre	auteur	date
Développer des applications Genai avec Golang	Haimtrann	25/03/2024

Développer des applications Genai avec Golang

Introduction

Ce que nous voyons souvent dans la production, c'est une variété sur les langues écrites dans Go, Java, .NET, mais la majorité des applications d'apprentissage sur la création d'applications Genai (Generative Artificical Intelligence) se trouve actuellement dans Python et JavaScript. Cet atelier montre comment démarrer avec Amazon Bedrock en passant par la mise en œuvre de quelques exemples de base sans utiliser de cadres comme Langchain, rationaliser ou réagir.

Les exemples incluent:

Chat simple et invite
Analyseur d'image simple
Base de données de vecteur de requête
Application de chiffon simple (récupération augmentée)

Vous metterez en œuvre ces fonctionnalités en utilisant uniquement des concepts de programmation de base sans avoir à apprendre un nouveau cadre pour vous aider à vraiment comprendre et maîtriser les concepts fondamentaux.

Réponse du flux
API Message du modèle anthropique Claude 3
Invitant Claude 3 sur le substratum rocheux d'Amazon

Architecture

cambre

Condition préalable

Cet exemple d'application suppose que vous avez déjà configuré

Autorisations pour invoquer le modèle Haiku Claude 3 sur le substratum rocheux d'Amazon
Vous lancez une base de connaissances AWS MAANGED
Autorisations pour invoquer la collection Amazon Opensearch Serverless (AOSS) et la base de connaissances gérée

Veuillez remplacer les variables dans /bedrock/constants.go par la vôtre, par exemple

 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 = ""

Application

Structure du projet

 | - - 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 implémentez un serveur HTTP et une demande d'itinéraire aux gestionnaires. Bedrock.go et aoss.go sont des fonctions pour invoquer le fondement Amazon et Amazon Opensearch Serverless (AOSS), respectivement. Le dossier statique contient un frontend simple avec JavaScript.

Important

Pour utiliser AOSS, vous devez créer une collection OpenSearch et fournir son point de terminaison URL dans constantes.go. De plus, vous devez configurer l'accès aux données dans l'Aoss pour l'environnement de temps d'exécution (profil EC2, Rôle ECS Taks, Lambda Role, .etc)

Comment courir

Suivez ce document officiel pour installer Golang, puis exécutez l'Applicationn comme le suivant

Important

Veuillez installer Go version 1.21.5

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

Réponse en streaming

Il est d'abord bon de créer certaines structures de données selon le format API Claude3 du fondement d'Amazon

 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 ,
}

Convertissez ensuite la charge utile en octets et invoquez le client du fondement

 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
}

Enfin, analysez la réponse de streaming et décochez au texte. Lors du déploiement sur un serveur HTTP, nous devons modifier un peu le code pour diffuser chaque morceau de réponse au client. Par exemple ici

 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" )
	}
}

Déploiement

Cet atelier ne fournit pas de détail détaillé étape par étape pour déployer l'application. Au lieu de cela, il fournit une architecture globale et une option de déploiement. Il est simple de déployer l'application sur Amazon ECS.

cambre

Les utilisateurs posent une question.
L'équilibreur de chargement d'application distribue la demande aux tâches Amazon ECS.
Les tâches ECS interrogent la base de connaissances.
Les tâches ECS reçoivent des vecteurs et des morceaux de texte qui sont pertinents pour la question de l'utilisateur.
Les tâches ECS construisent et envoient l'invite au modèle Claude 3 sur le substratum rocheux d'Amazon.
Le substratum rocheux d'Amazon diffuse la réponse aux tâches ECS.
Les tâches ECS diffusent la réponse à l'équilibreur de charge d'application.
L'équilibreur de charge d'application transmet la réponse aux utilisateurs.

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" ]

Rôle de tâche ECS

Le rôle de la tâche nécessite des autorisations pour

Invoquez le ruissellement du substratum rocheux d'Amazon
Invoquez l'exécution de l'agent du fondement amazon
Accès aux modèles Claude 3 et Titan
Téléchargez des données sur le seau S3 dans la base de connaissances
Accéder à la collection Aoss

Voici un échantillon de la politique IAM attachée au rôle de tâche

{
  "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 "
    }
  ]
}