From 39b1550012afd650f4602243ac6094e53cebd68b Mon Sep 17 00:00:00 2001 From: Zhongwei Li Date: Sun, 30 Nov 2025 08:21:43 +0800 Subject: [PATCH] Initial commit --- .claude-plugin/plugin.json | 15 + README.md | 3 + commands/create-agent.md | 376 ++++++++++++++ plugin.lock.json | 61 +++ skills/agent-sdk-master/SKILL.md | 511 +++++++++++++++++++ skills/agent-sdk-master/assets/README.md | 26 + skills/agent-sdk-master/references/README.md | 26 + skills/agent-sdk-master/scripts/README.md | 24 + 8 files changed, 1042 insertions(+) create mode 100644 .claude-plugin/plugin.json create mode 100644 README.md create mode 100644 commands/create-agent.md create mode 100644 plugin.lock.json create mode 100644 skills/agent-sdk-master/SKILL.md create mode 100644 skills/agent-sdk-master/assets/README.md create mode 100644 skills/agent-sdk-master/references/README.md create mode 100644 skills/agent-sdk-master/scripts/README.md diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json new file mode 100644 index 0000000..ecb9542 --- /dev/null +++ b/.claude-plugin/plugin.json @@ -0,0 +1,15 @@ +{ + "name": "004-jeremy-google-cloud-agent-sdk", + "description": "Google Cloud Agent Development Kit (ADK) and Agent Starter Pack mastery - build containerized multi-agent systems with production-ready templates, deploy to Cloud Run/GKE/Agent Engine, RAG agents, ReAct agents, and multi-agent orchestration.", + "version": "1.0.0", + "author": { + "name": "Jeremy Longshore", + "email": "jeremy@intentsolutions.io" + }, + "skills": [ + "./skills" + ], + "commands": [ + "./commands" + ] +} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..a60e18b --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# 004-jeremy-google-cloud-agent-sdk + +Google Cloud Agent Development Kit (ADK) and Agent Starter Pack mastery - build containerized multi-agent systems with production-ready templates, deploy to Cloud Run/GKE/Agent Engine, RAG agents, ReAct agents, and multi-agent orchestration. diff --git a/commands/create-agent.md b/commands/create-agent.md new file mode 100644 index 0000000..e39cd68 --- /dev/null +++ b/commands/create-agent.md @@ -0,0 +1,376 @@ +--- +name: create-agent +description: Create a production-ready Google Cloud agent using ADK and Agent Starter Pack with CI/CD, deployment, and testing infrastructure +model: sonnet +--- + +# Create Production-Ready Google Cloud Agent + +Scaffold a complete agent project using Google's Agent Development Kit (ADK) and Agent Starter Pack with production-ready infrastructure. + +## What This Does + +1. **Choose Agent Template**: Select from 5 production templates +2. **Configure Deployment**: Select deployment target (Cloud Run, GKE, Agent Engine) +3. **Generate Project**: Create complete project structure with CI/CD +4. **Setup Instructions**: Provide step-by-step deployment guide + +## Available Templates + +### 1. adk_base (ReAct Agent) +**Best for**: General-purpose agents with tool use +**Includes**: Search, code execution, custom tools +**Use case**: Q&A agents, research assistants, task automation + +### 2. agentic_rag (RAG Agent) +**Best for**: Document-based Q&A +**Includes**: Vertex AI Search, Vector Search integration +**Use case**: Knowledge bases, documentation agents, customer support + +### 3. langgraph_base_react (LangGraph) +**Best for**: Complex workflows with state management +**Includes**: LangGraph orchestration, custom nodes +**Use case**: Multi-step processes, conditional logic, state tracking + +### 4. crewai_coding_crew (Multi-Agent) +**Best for**: Collaborative multi-agent systems +**Includes**: Specialized agents, role-based coordination +**Use case**: Software development, research teams, content creation + +### 5. adk_live (Multimodal RAG) +**Best for**: Audio/video/text processing +**Includes**: Multimodal understanding, live streaming +**Use case**: Video analysis, audio transcription, media processing + +## Deployment Targets + +### Cloud Run (Serverless) +**Pros:** +- Automatic scaling 0→N +- Pay-per-use pricing +- Fast deployment +- Custom domains + +**Cons:** +- 60-minute timeout +- Limited memory (8GB max) + +**Best for:** Web-facing agents, APIs, low-traffic services + +### Agent Engine (Managed) +**Pros:** +- Fully managed runtime +- Built-in observability +- Auto-scaling +- Integrated with Vertex AI + +**Cons:** +- Vertex AI pricing +- Less customization + +**Best for:** Production agents, high-scale deployment + +### GKE (Kubernetes) +**Pros:** +- Full control +- Advanced networking +- Resource management +- Multi-cluster + +**Cons:** +- Higher complexity +- Cluster management overhead + +**Best for:** Complex multi-agent systems, enterprise deployment + +## Usage + +```bash +/create-agent +``` + +Then provide: +- Agent name +- Template choice +- Deployment target +- GCP project ID +- Region preference + +## Example Workflow + +**Input:** +``` +Agent name: customer-support-agent +Template: agentic_rag +Deployment: cloud_run +Project: my-gcp-project +Region: us-central1 +``` + +**Generated Structure:** +``` +customer-support-agent/ +├── src/ +│ ├── agent.py # Main agent implementation +│ ├── tools/ +│ │ ├── search_tool.py +│ │ └── custom_tools.py +│ ├── config.py # Configuration +│ └── prompts/ +│ └── system_prompt.txt +├── deployment/ +│ ├── Dockerfile +│ ├── cloudbuild.yaml +│ ├── cloud-run.yaml +│ └── terraform/ +│ ├── main.tf +│ ├── variables.tf +│ └── outputs.tf +├── tests/ +│ ├── unit/ +│ │ ├── test_agent.py +│ │ └── test_tools.py +│ └── integration/ +│ └── test_e2e.py +├── .github/workflows/ +│ ├── test.yaml # CI testing +│ └── deploy.yaml # CD deployment +├── requirements.txt +├── pyproject.toml +├── README.md +└── .env.example +``` + +## Step-by-Step Deployment + +### 1. Install Dependencies +```bash +cd customer-support-agent +python -m venv venv +source venv/bin/activate +pip install -r requirements.txt +``` + +### 2. Configure GCP +```bash +# Authenticate +gcloud auth login +gcloud config set project my-gcp-project + +# Enable APIs +gcloud services enable \ + aiplatform.googleapis.com \ + run.googleapis.com \ + cloudbuild.googleapis.com +``` + +### 3. Set Up Environment +```bash +# Copy example env +cp .env.example .env + +# Edit with your values +vim .env +``` + +**Required variables:** +```env +GOOGLE_CLOUD_PROJECT=my-gcp-project +GOOGLE_CLOUD_REGION=us-central1 +GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json +VERTEX_AI_SEARCH_DATASTORE=datastore-id +``` + +### 4. Test Locally +```bash +# Run agent locally +python src/agent.py + +# Or use ADK CLI +adk serve --port 8080 + +# Test endpoint +curl http://localhost:8080/query \ + -H "Content-Type: application/json" \ + -d '{"question": "What are your support hours?"}' +``` + +### 5. Run Tests +```bash +# Unit tests +pytest tests/unit/ + +# Integration tests +pytest tests/integration/ + +# Coverage report +pytest --cov=src tests/ +``` + +### 6. Deploy to Cloud Run +```bash +# Using ADK CLI (recommended) +adk deploy \ + --target cloud_run \ + --region us-central1 \ + --allow-unauthenticated + +# Or using gcloud +gcloud run deploy customer-support-agent \ + --source . \ + --region us-central1 \ + --allow-unauthenticated \ + --memory 2Gi \ + --cpu 2 \ + --timeout 300s +``` + +### 7. Setup CI/CD +```bash +# Connect GitHub repo +gh repo create customer-support-agent --public +git init +git add . +git commit -m "Initial agent setup" +git branch -M main +git remote add origin https://github.com/USER/customer-support-agent.git +git push -u origin main + +# GitHub Actions automatically trigger on push +``` + +### 8. Monitor Deployment +```bash +# View logs +gcloud run services logs read customer-support-agent \ + --region us-central1 \ + --limit 100 \ + --format json + +# Check metrics +gcloud monitoring dashboards create \ + --config-from-file monitoring/dashboard.json +``` + +## Advanced Features + +### RAG Integration +```python +# Automatically included in agentic_rag template +from vertexai.preview.rag import VectorSearchTool + +vector_search = VectorSearchTool( + index_endpoint="projects/PROJECT/locations/REGION/indexEndpoints/INDEX", + deployed_index_id="deployed_index" +) + +agent.add_tool(vector_search) +``` + +### Multi-Agent Orchestration +```python +# Automatically included in crewai_coding_crew template +from crewai import Agent, Task, Crew + +researcher = Agent( + role="Researcher", + goal="Research technical topics", + tools=[search_tool] +) + +writer = Agent( + role="Writer", + goal="Write documentation", + tools=[write_tool] +) + +crew = Crew( + agents=[researcher, writer], + tasks=[research_task, write_task] +) +``` + +### Custom Tools +```python +# Add custom tools to any agent +from vertexai.preview.agents import FunctionTool + +@FunctionTool +def check_inventory(product_id: str) -> dict: + """Check product inventory levels""" + # Your custom logic + return {"in_stock": True, "quantity": 42} + +agent.add_tool(check_inventory) +``` + +## Cost Estimation + +**Development:** +- Local testing: Free +- CI/CD (GitHub Actions): Free (2000 min/month) + +**Production (Cloud Run):** +- Idle: $0 (scales to zero) +- Active: ~$0.10/hour at moderate load +- Gemini API: $3.50/1M tokens + +**Monthly estimate for typical agent:** +- Infrastructure: $50-100 +- AI API costs: $100-300 +- Total: $150-400/month + +## Troubleshooting + +### Common Issues + +**1. Authentication Errors** +```bash +# Fix: Set credentials +export GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json +gcloud auth application-default login +``` + +**2. Timeout Errors** +```bash +# Fix: Increase Cloud Run timeout +gcloud run services update customer-support-agent \ + --timeout 300s +``` + +**3. Memory Issues** +```bash +# Fix: Increase memory +gcloud run services update customer-support-agent \ + --memory 4Gi +``` + +**4. Rate Limiting** +```bash +# Fix: Implement exponential backoff +# Code automatically included in templates +``` + +## Next Steps + +After deployment: +1. **Add custom tools** for your use case +2. **Configure RAG data sources** (if using agentic_rag) +3. **Set up monitoring alerts** +4. **Implement evaluation metrics** +5. **Scale based on traffic** + +## Resources + +**Documentation:** +- ADK Quickstart: https://google.github.io/adk-docs/ +- Agent Starter Pack: https://github.com/GoogleCloudPlatform/agent-starter-pack +- Cloud Run Docs: https://cloud.google.com/run/docs + +**Examples:** +- Agent Gallery: https://cloud.google.com/vertex-ai/generative-ai/docs/samples +- GitHub Samples: https://github.com/GoogleCloudPlatform/generative-ai + +--- + +**This command scaffolds production-ready agent projects in <5 minutes with full CI/CD, testing, and deployment automation.** diff --git a/plugin.lock.json b/plugin.lock.json new file mode 100644 index 0000000..3160fca --- /dev/null +++ b/plugin.lock.json @@ -0,0 +1,61 @@ +{ + "$schema": "internal://schemas/plugin.lock.v1.json", + "pluginId": "gh:jeremylongshore/claude-code-plugins-plus:plugins/productivity/004-jeremy-google-cloud-agent-sdk", + "normalized": { + "repo": null, + "ref": "refs/tags/v20251128.0", + "commit": "156f0162d98d3d4e34356274f2a6a3891e4f10d7", + "treeHash": "fd59a4e88bd1356e48c63f8415022905ab54a8bb1181a9a3052928601d784ef0", + "generatedAt": "2025-11-28T10:18:02.285330Z", + "toolVersion": "publish_plugins.py@0.2.0" + }, + "origin": { + "remote": "git@github.com:zhongweili/42plugin-data.git", + "branch": "master", + "commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390", + "repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data" + }, + "manifest": { + "name": "004-jeremy-google-cloud-agent-sdk", + "description": "Google Cloud Agent Development Kit (ADK) and Agent Starter Pack mastery - build containerized multi-agent systems with production-ready templates, deploy to Cloud Run/GKE/Agent Engine, RAG agents, ReAct agents, and multi-agent orchestration.", + "version": "1.0.0" + }, + "content": { + "files": [ + { + "path": "README.md", + "sha256": "702484aff7b742b872677177791a9ced7e9d71953118a59d291aedbf41e93868" + }, + { + "path": ".claude-plugin/plugin.json", + "sha256": "3d5c586be4c5bf914a39a52cfba8bed88fe8425c03d3fce13bf1e8ac53785cb4" + }, + { + "path": "commands/create-agent.md", + "sha256": "221851c3671fcc66e1ed7807b621407b6b7fd8975e73a37f775429cb50cd37e9" + }, + { + "path": "skills/agent-sdk-master/SKILL.md", + "sha256": "7e27a38edbdc140cd508b7283de121603ec54558e0a811980fb2a1e92a95698f" + }, + { + "path": "skills/agent-sdk-master/references/README.md", + "sha256": "db9680278e03728fef93321fc76c435387bc0c8fe1dcc9870bdf2fa236ea8ac3" + }, + { + "path": "skills/agent-sdk-master/scripts/README.md", + "sha256": "f042646ad5b685556c044080a6b73202a490fb8288be8219328faefc12d5a30e" + }, + { + "path": "skills/agent-sdk-master/assets/README.md", + "sha256": "33bfb083485b48c78a1738368c52cd9f202724a414bce507db181d8291b83aec" + } + ], + "dirSha256": "fd59a4e88bd1356e48c63f8415022905ab54a8bb1181a9a3052928601d784ef0" + }, + "security": { + "scannedAt": null, + "scannerVersion": null, + "flags": [] + } +} \ No newline at end of file diff --git a/skills/agent-sdk-master/SKILL.md b/skills/agent-sdk-master/SKILL.md new file mode 100644 index 0000000..7082ef5 --- /dev/null +++ b/skills/agent-sdk-master/SKILL.md @@ -0,0 +1,511 @@ +--- +name: Google Cloud Agent SDK Master +description: | + Automatic activation for ALL Google Cloud Agent Development Kit (ADK) and Agent Starter Pack operations - multi-agent systems, containerized deployment, RAG agents, and production orchestration. + **TRIGGER PHRASES:** + - "adk", "agent development kit", "agent starter pack", "multi-agent", "build agent" + - "cloud run agent", "gke deployment", "agent engine", "containerized agent" + - "rag agent", "react agent", "agent orchestration", "agent templates" + **AUTO-INVOKES FOR:** + - Agent creation and scaffolding + - Multi-agent system design + - Containerized agent deployment + - RAG (Retrieval-Augmented Generation) implementation + - CI/CD pipeline setup for agents + - Agent evaluation and monitoring +allowed-tools: Read, WebFetch, WebSearch, Grep +version: 1.0.0 +--- + +# Google Cloud Agent SDK Master - Production-Ready Agent Systems + +This Agent Skill provides comprehensive mastery of Google's Agent Development Kit (ADK) and Agent Starter Pack for building and deploying production-grade containerized agents. + +## Core Capabilities + +### 🤖 Agent Development Kit (ADK) + +**Framework Overview:** +- **Open-source Python framework** from Google +- Same framework powering Google Agentspace and CES +- Build production agents in <100 lines of code +- Model-agnostic (optimized for Gemini) +- Deployment-agnostic (local, Cloud Run, GKE, Agent Engine) + +**Supported Agent Types:** +1. **LLM Agents**: Dynamic routing with intelligence +2. **Workflow Agents**: + - Sequential: Linear execution + - Loop: Iterative processing + - Parallel: Concurrent execution +3. **Custom Agents**: User-defined implementations +4. **Multi-agent Systems**: Hierarchical coordination + +**Key Features:** +- Flexible orchestration (workflow & LLM-driven) +- Tool ecosystem (search, code execution, custom functions) +- Third-party integrations (LangChain, CrewAI) +- Agents-as-tools capability +- Built-in evaluation framework +- Cloud Trace integration + +### 📦 Agent Starter Pack + +**Production Templates:** +1. **adk_base** - ReAct agent using ADK +2. **agentic_rag** - Document retrieval + Q&A with search +3. **langgraph_base_react** - LangGraph ReAct implementation +4. **crewai_coding_crew** - Multi-agent coding system +5. **adk_live** - Multimodal RAG (audio/video/text) + +**Infrastructure Automation:** +- CI/CD setup with single command +- GitHub Actions or Cloud Build pipelines +- Multi-environment support (dev, staging, prod) +- Automated testing and evaluation +- Deployment rollback mechanisms + +### 🚀 Deployment Targets + +**1. Vertex AI Agent Engine** +- Fully managed runtime +- Auto-scaling and load balancing +- Built-in observability +- Serverless architecture +- Best for: Production-scale agents + +**2. Cloud Run** +- Containerized serverless +- Pay-per-use pricing +- Custom domain support +- Traffic splitting +- Best for: Web-facing agents + +**3. Google Kubernetes Engine (GKE)** +- Full container orchestration +- Advanced networking +- Resource management +- Multi-cluster support +- Best for: Complex multi-agent systems + +**4. Local/Docker** +- Development and testing +- Custom infrastructure +- On-premises deployment +- Best for: POC and debugging + +### 🔧 Technical Implementation + +**Installation:** +```bash +# Agent Starter Pack (recommended) +pip install agent-starter-pack + +# or direct from GitHub +uvx agent-starter-pack create my-agent + +# ADK only +pip install google-cloud-aiplatform[adk,agent_engines]>=1.111 +``` + +**Create Agent (ADK):** +```python +from google.cloud.aiplatform import agent +from vertexai.preview.agents import ADKAgent + +# Simple ReAct agent +@agent.adk_agent +class MyAgent(ADKAgent): + def __init__(self): + super().__init__( + model="gemini-2.5-pro", + tools=[search_tool, code_exec_tool] + ) + + def run(self, query: str): + return self.generate(query) + +# Multi-agent orchestration +class OrchestratorAgent(ADKAgent): + def __init__(self): + self.research_agent = ResearchAgent() + self.analysis_agent = AnalysisAgent() + self.writer_agent = WriterAgent() + + def run(self, task: str): + research = self.research_agent.run(task) + analysis = self.analysis_agent.run(research) + output = self.writer_agent.run(analysis) + return output +``` + +**Using Agent Starter Pack:** +```bash +# Create project with template +uvx agent-starter-pack create my-rag-agent \ + --template agentic_rag \ + --deployment cloud_run + +# Generates complete structure: +my-rag-agent/ +├── src/ +│ ├── agent.py # Agent implementation +│ ├── tools/ # Custom tools +│ └── config.py # Configuration +├── deployment/ +│ ├── Dockerfile +│ ├── cloudbuild.yaml +│ └── terraform/ +├── tests/ +│ ├── unit_tests.py +│ └── integration_tests.py +└── .github/workflows/ # CI/CD pipelines +``` + +**Deploy to Cloud Run:** +```bash +# Using ADK CLI +adk deploy \ + --target cloud_run \ + --region us-central1 \ + --service-account sa@project.iam.gserviceaccount.com + +# Manual with Docker +docker build -t gcr.io/PROJECT/agent:latest . +docker push gcr.io/PROJECT/agent:latest +gcloud run deploy agent \ + --image gcr.io/PROJECT/agent:latest \ + --region us-central1 \ + --allow-unauthenticated +``` + +**Deploy to Agent Engine:** +```bash +# Using Agent Starter Pack +asp deploy \ + --env production \ + --target agent_engine + +# Manual deployment +from google.cloud.aiplatform import agent_engines +agent_engines.deploy_agent( + agent_id="my-agent", + project="PROJECT_ID", + location="us-central1" +) +``` + +### 📊 RAG Agent Implementation + +**Vector Search Integration:** +```python +from vertexai.preview.rag import VectorSearchTool +from google.cloud import aiplatform + +# Set up vector search +vector_search = VectorSearchTool( + index_endpoint="projects/PROJECT/locations/LOCATION/indexEndpoints/INDEX_ID", + deployed_index_id="deployed_index" +) + +# RAG agent with ADK +class RAGAgent(ADKAgent): + def __init__(self): + super().__init__( + model="gemini-2.5-pro", + tools=[vector_search, web_search_tool] + ) + + def run(self, query: str): + # Retrieves relevant docs automatically + response = self.generate( + f"Answer this using retrieved context: {query}" + ) + return response +``` + +**Vertex AI Search Integration:** +```python +from vertexai.preview.search import VertexAISearchTool + +# Enterprise search integration +vertex_search = VertexAISearchTool( + data_store_id="DATA_STORE_ID", + project="PROJECT_ID" +) + +agent = ADKAgent( + model="gemini-2.5-pro", + tools=[vertex_search] +) +``` + +### 🔄 CI/CD Automation + +**GitHub Actions (auto-generated):** +```yaml +name: Deploy Agent +on: + push: + branches: [main] + +jobs: + deploy: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - name: Test Agent + run: pytest tests/ + - name: Deploy to Cloud Run + run: | + gcloud run deploy agent \ + --source . \ + --region us-central1 +``` + +**Cloud Build Pipeline:** +```yaml +steps: + # Build container + - name: 'gcr.io/cloud-builders/docker' + args: ['build', '-t', 'gcr.io/$PROJECT_ID/agent', '.'] + + # Run tests + - name: 'gcr.io/$PROJECT_ID/agent' + args: ['pytest', 'tests/'] + + # Deploy to Cloud Run + - name: 'gcr.io/cloud-builders/gcloud' + args: + - 'run' + - 'deploy' + - 'agent' + - '--image=gcr.io/$PROJECT_ID/agent' + - '--region=us-central1' +``` + +### 🎯 Multi-Agent Orchestration + +**Hierarchical Agents:** +```python +# Coordinator agent with specialized sub-agents +class ProjectManagerAgent(ADKAgent): + def __init__(self): + self.researcher = ResearchAgent() + self.analyst = AnalysisAgent() + self.writer = WriterAgent() + self.reviewer = ReviewAgent() + + def run(self, project_brief: str): + # Coordinate multiple agents + research = self.researcher.run(project_brief) + analysis = self.analyst.run(research) + draft = self.writer.run(analysis) + final = self.reviewer.run(draft) + return final +``` + +**Parallel Agent Execution:** +```python +import asyncio + +class ParallelResearchAgent(ADKAgent): + async def research_topic(self, topics: list[str]): + # Run multiple agents concurrently + tasks = [ + self.specialized_agent(topic) + for topic in topics + ] + results = await asyncio.gather(*tasks) + return self.synthesize(results) +``` + +### 📈 Evaluation & Monitoring + +**Built-in Evaluation:** +```python +from google.cloud.aiplatform import agent_evaluation + +# Define evaluation metrics +eval_config = agent_evaluation.EvaluationConfig( + metrics=["accuracy", "relevance", "safety"], + test_dataset="gs://bucket/eval_data.jsonl" +) + +# Run evaluation +results = agent.evaluate(eval_config) +print(f"Accuracy: {results.accuracy}") +print(f"Relevance: {results.relevance}") +``` + +**Cloud Trace Integration:** +```python +from google.cloud import trace_v1 + +# Automatic tracing +@traced_agent +class MonitoredAgent(ADKAgent): + def run(self, query: str): + # All calls automatically traced + with self.trace_span("retrieval"): + docs = self.retrieve(query) + + with self.trace_span("generation"): + response = self.generate(query, docs) + + return response +``` + +### 🔒 Security & Best Practices + +**1. Service Account Management:** +```bash +# Create minimal-permission service account +gcloud iam service-accounts create agent-sa \ + --display-name "Agent Service Account" + +# Grant only required permissions +gcloud projects add-iam-policy-binding PROJECT_ID \ + --member="serviceAccount:agent-sa@PROJECT.iam.gserviceaccount.com" \ + --role="roles/aiplatform.user" +``` + +**2. Secret Management:** +```python +from google.cloud import secretmanager + +def get_api_key(): + client = secretmanager.SecretManagerServiceClient() + name = "projects/PROJECT/secrets/api-key/versions/latest" + response = client.access_secret_version(name=name) + return response.payload.data.decode('UTF-8') +``` + +**3. VPC Service Controls:** +```bash +# Enable VPC SC for data security +gcloud access-context-manager perimeters create agent-perimeter \ + --resources=projects/PROJECT_ID \ + --restricted-services=aiplatform.googleapis.com +``` + +### 💰 Cost Optimization + +**Strategies:** +- Use Gemini 2.5 Flash for most operations +- Cache embeddings for RAG systems +- Implement request batching +- Use preemptible GKE nodes +- Monitor token usage in Cloud Monitoring + +**Pricing Examples:** +- Cloud Run: $0.00024/GB-second +- Agent Engine: Pay-per-request pricing +- GKE: Standard cluster costs +- Gemini API: $3.50/1M tokens (Pro) + +### 📚 Reference Architecture + +**Production Agent System:** +``` +┌─────────────────┐ +│ Load Balancer │ +└────────┬────────┘ + │ + ┌────▼────┐ + │Cloud Run│ (Agent containers) + └────┬────┘ + │ + ┌────▼──────────┐ + │ Agent Engine │ (Orchestration) + └────┬──────────┘ + │ + ┌────▼────────────────┐ + │ Vertex AI Search │ (RAG) + │ Vector Search │ + │ Gemini 2.5 Pro │ + └─────────────────────┘ +``` + +### 🎯 Best Practices for Jeremy + +**1. Start with Templates:** +```bash +# Use Agent Starter Pack templates +uvx agent-starter-pack create my-agent --template agentic_rag +``` + +**2. Local Development:** +```bash +# Test locally first +adk serve --port 8080 +curl http://localhost:8080/query -d '{"question": "test"}' +``` + +**3. Gradual Deployment:** +```bash +# Deploy to dev → staging → prod +asp deploy --env dev +# Test thoroughly +asp deploy --env staging +# Final production push +asp deploy --env production +``` + +**4. Monitor Everything:** +- Enable Cloud Trace +- Set up error reporting +- Track token usage +- Monitor response times +- Set up alerting + +### 📖 Official Documentation + +**Core Resources:** +- ADK Docs: https://google.github.io/adk-docs/ +- Agent Starter Pack: https://github.com/GoogleCloudPlatform/agent-starter-pack +- Agent Engine: https://cloud.google.com/vertex-ai/generative-ai/docs/agent-engine/overview +- Agent Builder: https://cloud.google.com/products/agent-builder + +**Tutorials:** +- Building AI Agents: https://codelabs.developers.google.com/devsite/codelabs/building-ai-agents-vertexai +- Multi-agent Systems: https://cloud.google.com/blog/products/ai-machine-learning/build-and-manage-multi-system-agents-with-vertex-ai + +## When This Skill Activates + +This skill automatically activates when you mention: +- Agent development, ADK, or Agent Starter Pack +- Multi-agent systems or orchestration +- Containerized agent deployment +- Cloud Run, GKE, or Agent Engine deployment +- RAG agents or ReAct agents +- Agent templates or scaffolding +- CI/CD for agents +- Production agent systems + +## Integration with Other Services + +**Google Cloud:** +- Vertex AI (Gemini, Search, Vector Search) +- Cloud Storage (data storage) +- Cloud Functions (triggers) +- Cloud Scheduler (automation) +- Cloud Logging & Monitoring + +**Third-party:** +- LangChain integration +- CrewAI orchestration +- Custom tool frameworks + +## Success Metrics + +**Track:** +- Agent response time (target: <2s) +- Evaluation scores (target: >85% accuracy) +- Deployment frequency (target: daily) +- System uptime (target: 99.9%) +- Cost per query (target: <$0.01) + +--- + +**This skill makes Jeremy a Google Cloud agent architecture expert with instant access to ADK, Agent Starter Pack, and production deployment patterns.** diff --git a/skills/agent-sdk-master/assets/README.md b/skills/agent-sdk-master/assets/README.md new file mode 100644 index 0000000..148d1c3 --- /dev/null +++ b/skills/agent-sdk-master/assets/README.md @@ -0,0 +1,26 @@ +# Skill Assets + +This directory contains static assets used by this skill. + +## Purpose + +Assets can include: +- Configuration files (JSON, YAML) +- Data files +- Templates +- Schemas +- Test fixtures + +## Guidelines + +- Keep assets small and focused +- Document asset purpose and format +- Use standard file formats +- Include schema validation where applicable + +## Common Asset Types + +- **config.json** - Configuration templates +- **schema.json** - JSON schemas +- **template.yaml** - YAML templates +- **test-data.json** - Test fixtures diff --git a/skills/agent-sdk-master/references/README.md b/skills/agent-sdk-master/references/README.md new file mode 100644 index 0000000..bf97184 --- /dev/null +++ b/skills/agent-sdk-master/references/README.md @@ -0,0 +1,26 @@ +# Skill References + +This directory contains reference materials that enhance this skill's capabilities. + +## Purpose + +References can include: +- Code examples +- Style guides +- Best practices documentation +- Template files +- Configuration examples + +## Guidelines + +- Keep references concise and actionable +- Use markdown for documentation +- Include clear examples +- Link to external resources when appropriate + +## Types of References + +- **examples.md** - Usage examples +- **style-guide.md** - Coding standards +- **templates/** - Reusable templates +- **patterns.md** - Design patterns diff --git a/skills/agent-sdk-master/scripts/README.md b/skills/agent-sdk-master/scripts/README.md new file mode 100644 index 0000000..9f9c7ad --- /dev/null +++ b/skills/agent-sdk-master/scripts/README.md @@ -0,0 +1,24 @@ +# Skill Scripts + +This directory contains optional helper scripts that support this skill's functionality. + +## Purpose + +Scripts here can be: +- Referenced by the skill for automation +- Used as examples for users +- Executed during skill activation + +## Guidelines + +- All scripts should be well-documented +- Include usage examples in comments +- Make scripts executable (`chmod +x`) +- Use `#!/bin/bash` or `#!/usr/bin/env python3` shebangs + +## Adding Scripts + +1. Create script file (e.g., `analyze.sh`, `process.py`) +2. Add documentation header +3. Make executable: `chmod +x script-name.sh` +4. Test thoroughly before committing