playbooks

home / skills / jeremylongshore / claude-code-plugins-plus-skills / vertex-agent-builder

vertex-agent-builder skill

/plugins/jeremy-vertex-ai/skills/vertex-agent-builder

This skill helps you scaffold and deploy production-ready Vertex AI agents with RAG, function calling, and guardrails, ensuring reliable, scalable deployments.

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill vertex-agent-builder

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
3.2 KB
---
name: vertex-agent-builder
description: |
  Build and deploy production-ready generative AI agents using Vertex AI, Gemini models, and Google Cloud infrastructure with RAG, function calling, and multi-modal capabilities. Use when appropriate context detected. Trigger with relevant phrases based on skill purpose.
allowed-tools: Read, Write, Edit, Grep, Bash(cmd:*)
version: 1.0.0
author: Jeremy Longshore <[email protected]>
license: MIT
---
# Vertex AI Agent Builder

Build and deploy production-ready agents on Vertex AI with Gemini models, retrieval (RAG), function calling, and operational guardrails (validation, monitoring, cost controls).

## Overview

- Produces an agent scaffold aligned with Vertex AI Agent Engine deployment patterns.
- Helps choose models/regions, design tool/function interfaces, and wire up retrieval.
- Includes an evaluation + smoke-test checklist so deployments don’t regress.

## Prerequisites

- Google Cloud project with Vertex AI API enabled
- Permissions to deploy/operate Agent Engine runtimes (or a local-only build target)
- If using RAG: a document source (GCS/BigQuery/Firestore/etc) and an embeddings/index strategy
- Secrets handled via env vars or Secret Manager (never committed)

## Instructions

1. Clarify the agent’s job (user intents, inputs/outputs, latency and cost constraints).
2. Choose model + region and define tool/function interfaces (schemas, error contracts).
3. Implement retrieval (if needed): chunking, embeddings, index, and a “citation-first” response format.
4. Add evaluation: golden prompts, offline checks, and a minimal online smoke test.
5. Deploy (optional): provide the exact deployment command/config and verify endpoints + permissions.
6. Add ops: logs/metrics, alerting, quota/cost guardrails, and rollback steps.

## Output

- A Vertex AI agent scaffold (code/config) with clear extension points
- A retrieval plan (when applicable) and a validation/evaluation checklist
- Optional: deployment commands and post-deploy health checks

## Error Handling

- Quota/region issues: detect the failing service/quota and propose a scoped fix.
- Auth failures: identify the principal and missing role; prefer least-privilege remediation.
- Retrieval failures: validate indexing/embedding dimensions and add fallback behavior.
- Tool/function errors: enforce structured error responses and add regression tests.

## Examples

**Example: RAG support agent**
- Request: “Deploy a support bot that answers from our docs with citations.”
- Result: ingestion plan, retrieval wiring, evaluation prompts, and a smoke test that verifies citations.

**Example: Multimodal intake agent**
- Request: “Build an agent that extracts structured fields from PDFs/images and routes tasks.”
- Result: schema-first extraction prompts, tool interface contracts, and validation examples.

## Resources

- Full detailed guide (kept for reference): `{baseDir}/references/SKILL.full.md`
- Repo standards (source of truth):
  - `000-docs/6767-a-SPEC-DR-STND-claude-code-plugins-standard.md`
  - `000-docs/6767-b-SPEC-DR-STND-claude-skills-standard.md`
- Vertex AI docs: https://cloud.google.com/vertex-ai/docs
- Agent Engine docs: https://cloud.google.com/vertex-ai/docs/agent-engine

Overview

This skill builds and deploys production-ready generative AI agents on Google Cloud using Vertex AI, Gemini models, and Agent Engine patterns. It scaffolds code, retrieval (RAG), function calling, multimodal handling, and operational guardrails so you get a deployable agent with validation and monitoring. The output includes deployment commands, evaluation checks, and clear extension points for customization.

How this skill works

The skill generates an agent scaffold aligned to Vertex AI Agent Engine deployment patterns, selecting model/region and wiring tool/function interfaces. When needed, it designs retrieval pipelines (chunking, embeddings, index) and enforces a citation-first response format. It also produces evaluation artifacts: golden prompts, offline checks, and a smoke test, plus deployment and post-deploy health checks.

When to use it

  • You need a production-grade conversational or multimodal agent on Vertex AI with RAG and function calling.
  • You want a scaffold that includes retrieval, structured tool interfaces, and deployment steps.
  • You require validation, monitoring, and cost/permission guardrails before production rollout.
  • You are integrating image/PDF intake or other multimodal inputs for structured extraction.
  • You need a repeatable evaluation and smoke-test checklist to prevent regressions.

Best practices

  • Clarify agent job: intents, expected inputs/outputs, latency and cost targets before scaffolding.
  • Prefer least-privilege service accounts and use Secret Manager or environment variables for secrets.
  • Adopt a citation-first RAG response format and validate embedding dimensions during ingestion.
  • Define explicit function/tool schemas and structured error contracts for robust function calling.
  • Add automated smoke tests and monitoring (logs, metrics, alerts) before routing traffic to the agent.

Example use cases

  • Support bot that answers from internal docs with inline citations and source links.
  • Multimodal intake agent that extracts structured fields from PDFs or images and routes tasks.
  • Knowledge worker assistant that calls internal tools via defined function interfaces.
  • Private search assistant using BigQuery or GCS-backed documents with an index and embeddings.
  • Staged deployment: local build, smoke test, then Agent Engine deployment with rollback steps.

FAQ

What are the prerequisites to use this skill?

A Google Cloud project with Vertex AI API enabled, permissions to deploy Agent Engine runtimes (or use a local-only target), and access to document sources if using RAG.

How does it handle failures in retrieval or function calls?

It adds validation for indexing and embedding dimensions, structured error responses for tools, fallback behaviors for retrieval failures, and regression tests to capture tool errors early.