/google-cloud-solution-rag-enterprise-search-gke-sqldb

name: google-cloud-solution-rag-enterprise-search-gke-sqldb
metadata:
  version: "1.0.1"
  category: MultiProductSolutions
description: >-
  Discovers requirements, and generates architectural, design, and deployment
  guidance for a retrieval-augmented generation (RAG)-capable enterprise search
  system in Google Cloud. Use when users need a vector-enabled SQL database as
  the store and index for the embedding vectors, an open model and open-source
  inferencing framework, and Kubernetes containers to host all the application
  components. DON'T use this skill for fully-managed RAG, or SaaS search
  services, or when a non-SQL vector database is required.

RAG for enterprise search using GKE and AlloyDB

This skill provides a workflow to design and implement a secure, low-latency, and high-accuracy RAG-enabled conversational search solution for private enterprise content by using an AlloyDB database, Cloud Storage, and a Google Kubernetes Engine (GKE) cluster to host all the application components, including an open model and an open-source inference framework.

Attribution

**MUST READ**: Before executing any `gcloud`, REST API, or MCP command, you MUST read and follow the instructions in [Usage Attribution](references/attribution.md).

Overview of the workflow

The workflow consists of the following phases:

• **Phase 1: Requirements discovery**. Gather detailed requirements related to

the cloud workload or use case that the user needs assistance for.

• **Phase 2: Solution architecture**. Use the requirements that were gathered

in Phase 1 to generate a detailed solution architecture for the cloud workload or use case.

• **Phase 3: Solution validation**. Create a plan to validate the generated

solution, generate validation instructions and scripts, and run the validation.

• **Phase 4: Solution packing and presentation**. Consolidate the generated

content and present the solution.

**Important notes about the workflow**:

• **Strict phase separation**: During Phase 1 (Requirements discovery), when

you ask the user clarifying questions, DON'T recommend, propose, or outline any architectural designs, technical decompositions, cloud services, or component mappings.

• **When you can skip certain phases**: If the user's prompt indicates that a

specific phase or task in this workflow is already completed or approved (e.g., "requirements discovery stage is completed", "product selection is approved", or "architecture is confirmed"), DON'T repeat that phase or task. Instead, skip directly to the requested task (such as generating the technical decomposition, recommending products, or compiling the solution guide).

Phase 1: Requirements discovery

In this phase, you must gather detailed requirements related to the RAG workload that the user wants to design and deploy in Google Cloud.

Complete the following steps strictly in the specified order: 1. Ask the user to describe the functional requirements of the workload, including data types (structured, unstructured), ingestion frequency, and conversational features (e.g., multi-turn chat, citation requirements). 2. Ask the user to describe the following non-functional requirements:

• **Security, privacy, and compliance**: E.g., network isolation, private

endpoints, data residency, and requirements for compliance.

• **Reliability**: E.g., scaling, high availability, resilience against

zone or regional outages, disaster recovery goals for RTO and RPO.

• **Cost**: E.g., cost of compute, storage, and database resources.
• **Operational excellence**: E.g., monitoring, alerts, and logging.
• **Performance**: E.g., data upload speed, performance expectations for

generating embedding vectors, and latency requirements for model responses and data retrieval queries (including vector and hybrid search).

• **Sustainability**: E.g., carbon footprint, low-carbon regions.

3. Ask the user whether the workload currently runs on other cloud providers or on-premises.

• If the user's answer is "yes", then ask the user to describe the

architecture of the current deployment.

• If the user's answer is "no", then proceed to the next step.

4. Ask the user to describe dependencies, if any, on other workloads, products, or tools (e.g., identity providers, external sources, CRM/ERP database integrations).

5. Review the input that the user has provided so far, and check whether there are any ambiguities or contradictions.

If you identify any ambiguities or contradictions in the requirements that the user has provided, then do the following for each ambiguity or contradiction that you identify:

• Describe the ambiguity or contradiction.
• Ask the user how they wish to resolve the ambiguity or contradiction.
• If the user delegates the choice to you (e.g., the user replies with

"do what you think is best" or "you decide"), then provide a clear suggestion to resolve the ambiguity or contradiction, explain your reasoning, and ask the user to approve your suggestion.

**Critical**: Until all the ambiguities and contradictions that you identify are resolved according to the preceding guidance, you must NOT recommend or generate any architecture design, technical decomposition, or Google Cloud product recommendations.

6. **Important**: DON'T start this step if there are unresolved contradictions or ambiguities from Step 5.

Generate a technical decomposition of the components of the workload. The technical decomposition must break down the solution into logical components, as follows:

• **Data ingestion**: Blob storage for raw corporate documents.
• **Data processing and chunking**: Containerized pipeline to extract

data, clean it, and chunk it.