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

Files (6)

• SKILL.md
• output-template.md · assets/
• attribution.md · references/
• design-recommendations.md · references/
• product-selection-recommendations.md · references/
• related-documentation.md · references/

SKILL.md (first lines)

# 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.
    *   **Embedding vectors generation**: Containerized service to convert data
        chunks to embedding vectors.
    *   **Storing and indexing the embedding vectors**: Vector-enabled SQL
        database for storing embedding vectors.
    *   **Handling non-vector data**: Preparing non-vector data, like tables,
        views, and aggregations for data retrieval. Analyzing whether any
        indexing, partitioning, or other performance techniques can be applied
        on the original data schema.
    *   **Query and retrieval**: Accepting client queries, identifying intent,
        and routing to a retrieval workflow, which might include conversion of
        the request to an embedding for semantic search, extracting and applying
        filters for filtered search or supplying all to the hybrid search.
    *   **Prompt augmentation**: Augmenting the prompts with the retrieved
        context.
    *   **Response generation**: Requesting and generating responses from the
        model.
    *   **Response sanity checks**: Evaluating responses using an AI model and
        performing procedural checks according to defined criteria.
7.  Ask the user to approve the generated technical decomposition.

From google/skills, Apache-2.0.

More from google/skills