Ta strona została przetłumaczona przez Cloud Translation API.

Dowiedz się, jak utworzyć i wdrożyć aplikację LangChain w Cloud Run

1. Omówienie

W tym praktycznym module dowiesz się, jak wdrożyć aplikację LangChain, która korzysta z Gemini do zadawania pytań dotyczących informacji o wersji Cloud Run.

Oto przykład działania aplikacji: jeśli zadasz pytanie „Czy mogę zamontować kontener Cloud Storage jako wolumin w Cloud Run?”, aplikacja odpowie „Tak, od 19 stycznia 2024 r.” lub podobnie.

Aby zwrócić uzasadnione odpowiedzi, aplikacja najpierw pobiera informacje o wersji Cloud Run podobne do pytania, a potem wyświetla Gemini zarówno pytanie, jak i informacje o wersji. (jest to wzór, który jest powszechnie nazywany RAG). Oto diagram przedstawiający architekturę aplikacji:

2. Konfiguracja i wymagania

Najpierw sprawdźmy, czy środowisko programistyczne jest prawidłowo skonfigurowane.

Aby wdrożyć zasoby potrzebne do działania aplikacji, musisz mieć projekt Google Cloud.
Aby wdrożyć aplikację, musisz zainstalować narzędzie gcloud na komputerze lokalnym, uwierzytelnić je i skonfigurować do korzystania z projektu.
- gcloud auth login
- gcloud config set project
Jeśli chcesz uruchomić aplikację na komputerze lokalnym (co jest zalecane), musisz się upewnić, że dane logowania domyślne aplikacji są prawidłowo skonfigurowane, w tym ustawienie projektu limitu.
- gcloud auth application-default login
- gcloud auth application-default set-quota-project
Musisz też mieć zainstalowane te programy:
- Python (wymagana wersja 3.11 lub nowsza)
- interfejs wiersza poleceń LangChain,
- poezja na temat zarządzania zależnościami.
- pipx, aby zainstalować i uruchomić interfejs wiersza poleceń LangChain i poezję w izolowanych środowiskach wirtualnych

Oto blog, który pomoże Ci rozpocząć instalowanie narzędzi wymaganych do wykonania tej procedury.

Cloud Workstations

Zamiast komputera lokalnego możesz też używać Cloud Workstations w Google Cloud. Pamiętaj, że od kwietnia 2024 r. ta wersja korzysta z Pythona w wersji niższej niż 3.11, więc przed rozpoczęciem pracy może być konieczne uaktualnienie Pythona.

Włącz interfejsy Cloud API

Najpierw uruchom to polecenie, aby mieć pewność, że skonfigurowano odpowiedni projekt Google Cloud:

gcloud config list project

Jeśli nie wyświetla się właściwy projekt, możesz go ustawić za pomocą tego polecenia:

gcloud config set project <PROJECT_ID>

Teraz włącz te interfejsy API:

gcloud services enable \
  bigquery.googleapis.com \
  sqladmin.googleapis.com \
  aiplatform.googleapis.com \
  cloudresourcemanager.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com \
  run.googleapis.com \
  secretmanager.googleapis.com

Wybierz region

Google Cloud jest dostępny w wielu lokalizacjach na całym świecie. Musisz wybrać jedną z nich, aby wdrożyć zasoby, których użyjesz w tym laboratorium. Ustaw region jako zmienną środowiskową w powłoce (późniejsze polecenia korzystają z tej zmiennej):

export REGION=us-central1

3. Tworzenie instancji wektorowej bazy danych

Kluczową funkcją tej aplikacji jest pobieranie informacji o wersji, które są istotne w stosunku do pytania użytkownika. Aby to zilustrować, jeśli zadajesz pytanie dotyczące Cloud Storage, możesz dodać do promptu następującą informację z notatki o wersji:

Możesz użyć wektorów dystrybucyjnych tekstu i wektorowej bazy danych, aby znaleźć informacje o wersji podobne pod względem semantycznym.

Pokażę Ci, jak używać PostgreSQL w Cloud SQL jako wektorowej bazy danych. Tworzenie nowej instancji Cloud SQL zajmuje trochę czasu, więc zróbmy to teraz.

gcloud sql instances create sql-instance \
  --database-version POSTGRES_14 \
  --tier db-f1-micro \
  --region $REGION

Możesz uruchomić to polecenie i kontynuować kolejne kroki. W pewnym momencie konieczne będzie utworzenie bazy danych i dodanie użytkownika, ale nie traćmy czasu na obserwowanie wskaźnika postępu.

PostgreSQL to serwer relacyjnej bazy danych, a w każdej nowej instancji Cloud SQL jest domyślnie instalowane rozszerzenie pgvector, co oznacza, że możesz też używać tej bazy danych jako bazy danych wektorowej.

4. Tworzenie szablonu aplikacji LangChain

Aby kontynuować, musisz mieć zainstalowany interfejs wiersza poleceń LangChain i narzędzie poetry do zarządzania zależnościami. Oto jak zainstalować te pakiety za pomocą pipx:

pipx install langchain-cli poetry

Rozbuduj aplikację LangChain za pomocą następującego polecenia. Gdy pojawi się prośba, nadaj folderowi nazwę run-rag i przejdź do instalowania pakietów, naciskając klawisz Enter:

langchain app new

Przejdź do katalogu run-rag i zainstaluj zależności

poetry install

Właśnie utworzysz aplikację LangServe. LangServe otacza FastAPI łańcuchem LangChain. Zawiera wbudowany Playground, który ułatwia wysyłanie promptów i sprawdzanie wyników, w tym wszystkich pośrednich kroków. Otwórz folder run-rag w swojej aplikacji do edycji i sprawdź, co się w nim znajduje.

5. Tworzenie zadania indeksowania

Zanim zaczniesz tworzyć aplikację internetową, sprawdź, czy informacje o wersji Cloud Run są zindeksowane w bazie danych Cloud SQL. W tej sekcji utworzysz zadanie indeksowania, które wykona te czynności:

Zadaniem indeksowania jest pobieranie informacji o wersji, konwertowanie ich na wektory za pomocą modelu tekstowego i przechowywanie w bazie danych wektorów. Dzięki temu można sprawnie wyszukiwać podobne informacje o wersji na podstawie ich znaczenia semantycznego.

W folderze run-rag/app utwórz plik indexer.py z podaną niżej treścią:

import os
from google.cloud.sql.connector import Connector
import pg8000
from langchain_community.vectorstores.pgvector import PGVector
from langchain_google_vertexai import VertexAIEmbeddings
from google.cloud import bigquery


# Retrieve all Cloud Run release notes from BigQuery 
client = bigquery.Client()
query = """
SELECT
  CONCAT(FORMAT_DATE("%B %d, %Y", published_at), ": ", description) AS release_note
FROM `bigquery-public-data.google_cloud_release_notes.release_notes`
WHERE product_name= "Cloud Run"
ORDER BY published_at DESC
"""
rows = client.query(query)

print(f"Number of release notes retrieved: {rows.result().total_rows}")

# Set up a PGVector instance 
connector = Connector()

def getconn() -> pg8000.dbapi.Connection:
    conn: pg8000.dbapi.Connection = connector.connect(
        os.getenv("DB_INSTANCE_NAME", ""),
        "pg8000",
        user=os.getenv("DB_USER", ""),
        password=os.getenv("DB_PASS", ""),
        db=os.getenv("DB_NAME", ""),
    )
    return conn

store = PGVector(
    connection_string="postgresql+pg8000://",
    use_jsonb=True,
    engine_args=dict(
        creator=getconn,
    ),
    embedding_function=VertexAIEmbeddings(
        model_name="textembedding-gecko@003"
    ),
    pre_delete_collection=True  
)

# Save all release notes into the Cloud SQL database
texts = list(row["release_note"] for row in rows)
ids = store.add_texts(texts)

print(f"Done saving: {len(ids)} release notes")

Dodaj wymagane zależności:

poetry add \
  "cloud-sql-python-connector[pg8000]" \
  langchain-google-vertexai==1.0.5 \
  langchain-community==0.2.5 \
  pgvector

Tworzenie bazy danych i użytkownika

Utwórz bazę danych release-notes w instancji Cloud SQL sql-instance:

gcloud sql databases create release-notes --instance sql-instance

Utwórz użytkownika bazy danych o nazwie app:

gcloud sql users create app --instance sql-instance --password "myprecious"

Wdrażanie i uruchamianie zadania indeksowania

Teraz wdróż i uruchom zadanie:

DB_INSTANCE_NAME=$(gcloud sql instances describe sql-instance --format="value(connectionName)")

gcloud run jobs deploy indexer \
  --source . \
  --command python \
  --args app/indexer.py \
  --set-env-vars=DB_INSTANCE_NAME=$DB_INSTANCE_NAME \
  --set-env-vars=DB_USER=app \
  --set-env-vars=DB_NAME=release-notes \
  --set-env-vars=DB_PASS=myprecious \
  --region=$REGION \
  --execute-now

To długie polecenie. Zobaczmy, co się dzieje:

Pierwsze polecenie pobiera nazwę połączenia (unikalny identyfikator w formacie project:region:instance) i ustawia ją jako zmienną środowiskową DB_INSTANCE_NAME.

Drugie polecenie wdraża zadanie Cloud Run. Oto, co oznaczają flagi:

--source .: określa, że kod źródłowy zadania znajduje się w bieżącym katalogu roboczym (katalogu, w którym uruchomiono polecenie).
--command python: określa polecenie do wykonania w kontenerze. W tym przypadku jest to uruchamianie Pythona.
--args app/indexer.py: podaje argumenty polecenia w języku Python. Zapewnia to uruchomienie skryptu indexer.py w katalogu aplikacji.
--set-env-vars: ustawia zmienne środowiskowe, do których skrypt Pythona ma dostęp podczas wykonywania.
--region=$REGION: określa region, w którym zadanie ma zostać wdrożone.
--execute-now: informuje Cloud Run o konieczności uruchomienia zadania natychmiast po jego wdrożeniu.

Aby sprawdzić, czy zadanie zostało wykonane, możesz wykonać te czynności:

Odczytuj logi wykonania zadania w konsoli internetowej. Powinien on zawierać komunikat „Zakończono zapisywanie: xxx informacji o wersji” (gdzie xxx to liczba zapisanych informacji o wersji).
Możesz też przejść do instancji Cloud SQL w konsoli internetowej i za pomocą Cloud SQL Studio wykonać zapytanie o liczbę rekordów w tabeli langchain_pg_embedding.

6. Tworzenie aplikacji internetowej

Otwórz plik app/server.py w edytorze. Znajdziesz tam wiersz z tą informacją:

# Edit this to add the chain you want to add

Zastąp ten komentarz następującym fragmentem:

# (1) Initialize VectorStore
connector = Connector()


def getconn() -> pg8000.dbapi.Connection:
    conn: pg8000.dbapi.Connection = connector.connect(
        os.getenv("DB_INSTANCE_NAME", ""),
        "pg8000",
        user=os.getenv("DB_USER", ""),
        password=os.getenv("DB_PASS", ""),
        db=os.getenv("DB_NAME", ""),
    )
    return conn


vectorstore = PGVector(
    connection_string="postgresql+pg8000://",
    use_jsonb=True,
    engine_args=dict(
        creator=getconn,
    ),
    embedding_function=VertexAIEmbeddings(
        model_name="textembedding-gecko@003"
    )
)

# (2) Build retriever


def concatenate_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)


notes_retriever = vectorstore.as_retriever() | concatenate_docs

# (3) Create prompt template
prompt_template = PromptTemplate.from_template(
    """You are a Cloud Run expert answering questions. 
Use the retrieved release notes to answer questions
Give a concise answer, and if you are unsure of the answer, just say so.

Release notes: {notes}

Here is your question: {query}
Your answer: """)

# (4) Initialize LLM
llm = VertexAI(
    model_name="gemini-1.0-pro-001",
    temperature=0.2,
    max_output_tokens=100,
    top_k=40,
    top_p=0.95
)

# (5) Chain everything together
chain = (
    RunnableParallel({
        "notes": notes_retriever,
        "query": RunnablePassthrough()
    })
    | prompt_template
    | llm
    | StrOutputParser()
)

Musisz też dodać te importy:

import pg8000
import os
from google.cloud.sql.connector import Connector
from langchain_google_vertexai import VertexAI
from langchain_google_vertexai import VertexAIEmbeddings
from langchain_core.runnables import RunnablePassthrough, RunnableParallel
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_community.vectorstores.pgvector import PGVector

Na koniec zmień wiersz z informacją „NotImplemented” (Nie zaimplementowano). do:

# add_routes(app, NotImplemented)
add_routes(app, chain)

7. Wdrażanie aplikacji internetowej w Cloud Run

W katalogu run-rag użyj tego polecenia, aby wdrożyć aplikację w Cloud Run:

DB_INSTANCE_NAME=$(gcloud sql instances describe sql-instance --format="value(connectionName)")

gcloud run deploy run-rag \
  --source . \
  --set-env-vars=DB_INSTANCE_NAME=$DB_INSTANCE_NAME \
  --set-env-vars=DB_USER=app \
  --set-env-vars=DB_NAME=release-notes \
  --set-env-vars=DB_PASS=myprecious \
  --region=$REGION \
  --allow-unauthenticated

To polecenie wykonuje te operacje:

Przesyłanie kodu źródłowego do Cloud Build
Uruchom kompilację Dockera.
Prześlij powstały obraz kontenera do Artifact Registry.
Utwórz usługę Cloud Run za pomocą obrazu kontenera.

Po zakończeniu wykonywania polecenia wyświetli się adres URL HTTPS w domenie run.app. To jest publiczny adres URL Twojej nowej usługi Cloud Run

8. Poznaj plac zabaw

Otwórz adres URL usługi Cloud Run i przejdź do /playground. Otworzy się pole tekstowe. Służy on do zadawania pytań w informacjach o wersji Cloud Run, na przykład:

9. Gratulacje

Udało Ci się skompilować i wdrożyć aplikację LangChain w Cloud Run. Brawo!

Oto najważniejsze pojęcia:

Wykorzystanie platformy LangChain do stworzenia aplikacji Retrieval Augmented Generation (RAG).
Korzystanie z PostgreSQL w Cloud SQL jako wektorowej bazy danych z użyciem narzędzia pgvector, który jest domyślnie instalowany w Cloud SQL.
Uruchamianie dłuższego zadania indeksowania jako zadania Cloud Run, a aplikacji internetowej jako usługi Cloud Run.
Opakuj łańcuch LangChain do aplikacji FastAPI za pomocą LangServe, by mieć wygodny interfejs do interakcji z aplikacją RAG.

Czyszczenie danych

Oto czynności, które musisz wykonać, aby uniknąć obciążenia konta Google Cloud Platform opłatami za zasoby zużyte w tym samouczku:

W konsoli Cloud otwórz stronę Zarządzanie zasobami.
Na liście projektów wybierz swój projekt i kliknij Usuń.
W oknie wpisz identyfikator projektu i kliknij Wyłącz, aby usunąć projekt.

Jeśli chcesz zachować projekt, usuń te zasoby:

Instancja Cloud SQL
Usługa Cloud Run
Zadanie Cloud Run