# How to Configure the Agent Platform RAG Engine: A Complete Setup Guide

> Configure the Agent Platform RAG engine with this complete guide. Learn to authenticate, initialize the SDK, discover corpora, and set up VertexRagStore for context retrieval.

- Repository: [Google/skills](https://github.com/google/skills)
- Tags: how-to-guide
- Published: 2026-08-13

---

**To configure the Agent Platform RAG engine, authenticate to Google Cloud, initialize the Vertex AI SDK, discover your corpora, and configure a `VertexRagStore` tool to retrieve and ground context in Gemini model requests.**

Setting up the Agent Platform RAG engine enables your LLM applications to generate responses grounded in proprietary document corpora. According to the `google/skills` repository, the complete configuration workflow is documented in [`skills/cloud/agent-platform-rag-engine-management/SKILL.md`](https://github.com/google/skills/blob/main/skills/cloud/agent-platform-rag-engine-management/SKILL.md) and consists of three logical layers: environment setup, corpus discovery, and retrieval-augmented generation tooling. This guide walks through each layer using the exact method signatures and parameters defined in the source code.

## Prerequisites and Environment Setup

Before interacting with the Agent Platform RAG engine, you must establish Google Cloud credentials and install the required SDKs. As specified in lines 47-71 of the skill definition, this involves authenticating via the `gcloud` CLI and installing `google-cloud-aiplatform` for corpus operations and `google-genai` for model interactions.

Run the following commands once to prepare your environment:

```bash

# Authenticate with Google Cloud

gcloud auth login
gcloud auth application-default login

# Create and activate a virtual environment

python3 -m venv ~/rag_agent_venv
source ~/rag_agent_venv/bin/activate

# Install the required SDKs

pip install google-cloud-aiplatform google-genai

```

## Initializing Vertex AI and Discovering Corpora

Once authenticated, initialize the Vertex AI client with your **project ID** and **region** to enable API calls. The SDK automatically handles pagination when listing corpora, though manual pagination controls are available for large-scale projects (lines 107-131).

```python
import vertexai
from vertexai.preview import rag

# Replace with your values

project_id = "my-project"
region     = "us-central1"

vertexai.init(project=project_id, location=region)

# List all corpora (automatic pagination)

all_corpora = list(rag.list_corpora())
print(f"Found {len(all_corpora)} corpora:")
for c in all_corpora:
    print(f"- {c.display_name} ({c.name})")

```

### Listing Files Within a Corpus

To verify indexed content before retrieval, enumerate files inside a specific corpus using its resource name. This step is optional but recommended for confirming that your documents are properly ingested.

```python
corpus_name = f"projects/{project_id}/locations/{region}/ragCorpora/your-corpus-id"

files = list(rag.list_files(corpus_name=corpus_name))
print(f"Found {len(files)} files in the corpus:")
for f in files:
    print(f"- {f.display_name} ({f.name})")

```

## Configuring RAG Retrieval and Generation

The final configuration layer connects your corpus to a Gemini model through the **`VertexRagStore`** tool. This process involves executing a retrieval query to fetch relevant passages, then supplying those passages to the model via a tool configuration that includes retrieval parameters like `top_k` and `vector_similarity_threshold` (lines 190-236).

### Retrieving Context with `rag.retrieval_query`

Use the `rag.retrieval_query` function to fetch the most relevant document fragments for a user query. The `similarity_top_k` parameter controls how many passages are returned for grounding.

```python
query = "What is the speed of light?"

response = rag.retrieval_query(
    rag_corpora=[corpus_name],
    text=query,
    similarity_top_k=3          # Return the 3 most similar passages

)

for ctx in response.contexts.contexts:
    print("Context:", ctx.text)
    print("Source :", ctx.source_uri)

```

### Grounding Gemini with `VertexRagStore`

Construct a **`VertexRagStore`** tool definition that points to your corpus and specifies retrieval behavior. Pass this tool to the model's `generate_content` method to produce answers grounded in your documents.

```python
from google import genai
from google.genai import types

client = genai.Client(enterprise=True, project=project_id, location=region)

# Define the RAG tool that points to the corpus

rag_tool = types.Tool(
    retrieval=types.Retrieval(
        vertex_rag_store=types.VertexRagStore(
            rag_resources=[
                types.VertexRagStoreRagResource(rag_corpus=corpus_name)
            ],
            rag_retrieval_config=types.RagRetrievalConfig(
                top_k=3,
                filter=types.RagRetrievalConfigFilter(
                    vector_similarity_threshold=0.5
                ),
            ),
        )
    )
)

# Generate a grounded answer

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="What is the speed of light?",
    config=types.GenerateContentConfig(tools=[rag_tool])
)

print("Grounded answer:", response.text)

```

## Summary

- **Authenticate** to Google Cloud and install `google-cloud-aiplatform` and `google-genai` to establish API credentials and dependencies.
- **Initialize** Vertex AI with `vertexai.init()` using your project ID and region, then discover available corpora via `rag.list_corpora()`.
- **Retrieve** relevant context by calling `rag.retrieval_query()` with `rag_corpora` and `similarity_top_k` parameters to fetch specific document passages.
- **Ground** Gemini model responses by configuring a `VertexRagStore` tool with `rag_retrieval_config` settings including `top_k` and `vector_similarity_threshold`, enabling traceable, source-cited generation.

## Frequently Asked Questions

### What Python SDKs are required to configure the Agent Platform RAG engine?

You need `google-cloud-aiplatform` for corpus and retrieval operations, and `google-genai` for model inference. Install both via pip after running `gcloud auth application-default login` to ensure your environment has proper credentials.

### How do I locate the resource name for my RAG corpus?

After initializing Vertex AI with `vertexai.init()`, call `list(rag.list_corpora())` to enumerate all corpora. Each returned object contains a `name` attribute formatted as `projects/{project_id}/locations/{region}/ragCorpora/{corpus_id}`, which serves as the unique identifier for subsequent operations.

### Which parameters control the quality and quantity of retrieved context?

The `similarity_top_k` parameter in `rag.retrieval_query()` and the `top_k` field within `RagRetrievalConfig` define how many passages are fetched. Additionally, setting `vector_similarity_threshold` in `RagRetrievalConfigFilter` excludes low-relevance chunks below the specified semantic similarity score.

### Can I query multiple corpora in a single generation request?

Yes, the `rag_resources` list inside `VertexRagStore` accepts multiple `VertexRagStoreRagResource` objects. By appending additional corpus resource names to this list, you can retrieve context across several document collections simultaneously for broader knowledge coverage.