@intentsolutionsio/jeremy-gcp-starter-examples 2.1.0

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@intentsolutionsio/jeremy-gcp-starter-examples",
+  "version": "2.1.0",
+  "description": "Google Cloud starter kits and example code aggregator with ADK samples",
+  "keywords": [
+    "google-cloud",
+    "adk-samples",
+    "genkit-examples",
+    "vertex-ai",
+    "agent-starter-pack",
+    "code-examples",
+    "starter-kits",
+    "templates",
+    "claude-code",
+    "claude-plugin",
+    "tonsofskills"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jeremylongshore/claude-code-plugins-plus-skills.git",
+    "directory": "plugins/ai-ml/jeremy-gcp-starter-examples"
+  },
+  "homepage": "https://tonsofskills.com/plugins/jeremy-gcp-starter-examples",
+  "bugs": "https://github.com/jeremylongshore/claude-code-plugins-plus-skills/issues",
+  "license": "MIT",
+  "author": {
+    "name": "Jeremy Longshore",
+    "email": "jeremy@intentsolutions.io"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    ".claude-plugin",
+    "skills",
+    "agents"
+  ],
+  "scripts": {
+    "postinstall": "node -e \"console.log(\\\"\\\\n→ This npm package is a tracking/proof artifact. Install the plugin via:\\\\n  ccpi install jeremy-gcp-starter-examples\\\\n  or /plugin install jeremy-gcp-starter-examples@claude-code-plugins-plus in Claude Code\\\\n\\\")\""
+  }
+}

package/skills/gcp-examples-expert/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: gcp-examples-expert
+description: |
+  Generate production-ready Google Cloud code examples from official repositories including ADK samples, Genkit templates, Vertex AI notebooks, and Gemini patterns. Use when asked to "show ADK example" or "provide GCP starter kit". Trigger with relevant phrases based on skill purpose.
+allowed-tools: Read, Write, Edit, Grep, Glob, Bash(cmd:*)
+version: 2.1.0
+author: Jeremy Longshore <jeremy@intentsolutions.io>
+license: MIT
+effort: medium
+argument-hint: "[framework or use-case]"
+compatible-with: claude-code, codex, openclaw
+tags: [ai, gcp, gcp-examples]
+---
+# GCP Examples Expert
+
+## Overview
+
+Generate production-ready Google Cloud Platform code examples sourced from official repositories including ADK samples, Agent Starter Pack, Firebase Genkit, Vertex AI samples, Generative AI examples, and AgentSmithy. This skill maps user requirements to the appropriate GCP framework and delivers working code with security, monitoring, and deployment best practices baked in.
+
+## Prerequisites
+
+- Google Cloud project with billing enabled and Vertex AI API activated
+- `gcloud` CLI authenticated with appropriate IAM roles (Vertex AI User, Cloud Run Developer)
+- Node.js 18+ for Genkit/TypeScript examples or Python 3.10+ for ADK/Vertex AI examples
+- Firebase CLI for Genkit deployments (`npm install -g firebase-tools`)
+- API keys or service account credentials configured via Secret Manager (never hardcoded)
+
+## Instructions
+
+1. Identify the target framework by matching the request to one of six categories: ADK agents, Agent Starter Pack, Genkit flows, Vertex AI training, Generative AI multimodal, or AgentSmithy orchestration
+2. Select the appropriate source repository and code pattern from `${CLAUDE_SKILL_DIR}/references/code-example-categories.md`
+3. Adapt the template to the specified programming language (TypeScript, Python, or Go)
+4. Configure security settings: IAM least-privilege service accounts, VPC Service Controls, Model Armor for prompt injection protection
+5. Add monitoring instrumentation: Cloud Monitoring dashboards, alerting policies, structured logging, OpenTelemetry tracing
+6. Set auto-scaling parameters with appropriate min/max instance counts for the deployment target
+7. Include cost optimization: select Gemini 2.5 Flash for simple tasks, Gemini 2.5 Pro for complex reasoning, batch predictions for bulk workloads
+8. Generate deployment configuration for the target platform (Cloud Run, Firebase Functions, or Vertex AI Endpoints)
+9. Provide Terraform or IaC templates for reproducible infrastructure provisioning
+10. Cite the source repository and link to official documentation for each pattern used
+
+See `${CLAUDE_SKILL_DIR}/references/workflow.md` for the phased workflow and `${CLAUDE_SKILL_DIR}/references/best-practices-applied.md` for the full best-practices checklist.
+
+## Output
+
+- Complete, runnable code example with imports, configuration, and error handling
+- Deployment configuration (Cloud Run service YAML, Firebase function config, or Terraform module)
+- Environment variable template listing required secrets and API keys
+- Monitoring setup: dashboard JSON, alerting policy definitions, log-based metrics
+- Cost estimate guidance based on model selection and expected throughput
+- Source repository citation and documentation links
+
+## Error Handling
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| Invalid GCP project or API not enabled | Vertex AI API disabled or project ID misconfigured | Run `gcloud services enable aiplatform.googleapis.com`; verify project ID in `gcloud config list` |
+| Permission denied on Vertex AI resources | Service account missing required IAM roles | Grant `roles/aiplatform.user` and `roles/run.developer`; check VPC-SC perimeter allows access |
+| Model not available in region | Requested Gemini model not deployed in specified location | Use `us-central1` or `europe-west4` where Gemini models are available; check regional availability docs |
+| Quota exceeded for API calls | Rate limit hit on Vertex AI prediction endpoint | Request quota increase via Cloud Console; implement exponential backoff with jitter |
+| Dependency version conflict | Incompatible versions of AI SDK, Genkit, or provider packages | Pin versions in `package.json` or `requirements.txt`; use lockfile to ensure reproducibility |
+
+See `${CLAUDE_SKILL_DIR}/references/errors.md` for additional error scenarios.
+
+## Examples
+
+**Scenario 1: ADK Agent with Code Execution** -- Create a production ADK agent using `google/adk-samples` patterns. Enable Code Execution Sandbox with 14-day state TTL, configure Memory Bank for persistent context, apply VPC Service Controls and IAM least-privilege. Deploy to Vertex AI Agent Engine.
+
+**Scenario 2: Genkit RAG Flow** -- Implement a retrieval-augmented generation system using Firebase Genkit. Define a retriever with text-embedding-gecko embeddings, connect to a vector database, build a RAG flow with Zod-validated input/output schemas. Deploy to Cloud Run with auto-scaling (2-10 instances).
+
+**Scenario 3: Gemini Multimodal Analysis** -- Analyze video content using the `generative-ai` repository patterns. Create a multimodal prompt combining video URIs with text questions using Gemini 2.5 Pro. Include safety filter configuration, token counting for cost estimation, and structured output parsing.
+
+See `${CLAUDE_SKILL_DIR}/references/example-interactions.md` for detailed interaction examples.
+
+## Resources
+
+- [google/adk-samples](https://github.com/google/adk-samples) -- ADK agent creation patterns
+- [GoogleCloudPlatform/agent-starter-pack](https://github.com/GoogleCloudPlatform/agent-starter-pack) -- production agent templates
+- [genkit-ai/genkit](https://github.com/genkit-ai/genkit) -- RAG flows, tool calling, evaluation
+- [GoogleCloudPlatform/vertex-ai-samples](https://github.com/GoogleCloudPlatform/vertex-ai-samples) -- model training, tuning, deployment
+- [GoogleCloudPlatform/generative-ai](https://github.com/GoogleCloudPlatform/generative-ai) -- Gemini multimodal, function calling, grounding
+- [GoogleCloudPlatform/agentsmithy](https://github.com/GoogleCloudPlatform/agentsmithy) -- multi-agent orchestration

package/skills/gcp-examples-expert/references/ARD.md

@@ -0,0 +1,72 @@
+# ARD: GCP Examples Expert
+
+> Part of [Tons of Skills](https://tonsofskills.com) by [Intent Solutions](https://intentsolutions.io) | [jeremylongshore.com](https://jeremylongshore.com)
+
+## System Context
+
+The GCP Examples Expert maps developer requirements to the correct Google Cloud AI repository and generates production-ready code adapted from official patterns. It operates as a code generation skill that bridges six official GCP AI repositories.
+
+```
+Developer Request ("Build a RAG system on GCP")
+       ↓
+[GCP Examples Expert]
+  ├── Maps to: Framework selection (Genkit, ADK, Vertex AI, etc.)
+  ├── Sources: 6 official GCP repositories
+  ├── Adapts: language, security, monitoring, deployment
+  └── Generates: runnable code + deployment config + IaC
+       ↓
+Production-Ready Code Package
+  ├── Application code (adapted from source repo)
+  ├── Deployment config (Cloud Run / Functions / Agent Engine)
+  ├── Terraform module (infrastructure)
+  └── Documentation (source citations, cost estimates)
+```
+
+## Data Flow
+
+1. **Input**: User request describing the AI use case, preferred language, and deployment target. May include constraints like model preference, cost budget, or compliance requirements.
+2. **Processing**: Classify the request into one of six framework categories. Select the matching code pattern from the categorized reference. Adapt to the target language. Layer on security (IAM, VPC-SC, Secret Manager), monitoring (OpenTelemetry, dashboards), and deployment configuration. Generate Terraform when infrastructure provisioning is needed.
+3. **Output**: Complete code package with application files, deployment config (YAML/JSON), Terraform module, environment variable template, monitoring setup, cost estimate, and source repository citations.
+
+## Key Design Decisions
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| Six-category framework taxonomy | ADK, Starter Pack, Genkit, Vertex AI, Gen AI, AgentSmithy | Covers the complete GCP AI landscape; each category maps to a distinct official repo |
+| Security-by-default | Every example includes IAM, Secret Manager, and VPC-SC | Production examples must not teach insecure patterns; developers copy-paste examples |
+| Source attribution | Cite the specific repo and pattern for every adaptation | Enables developers to find updates and deeper documentation; maintains trust |
+| Model selection guidance | Gemini 2.5 Flash for throughput, Pro for reasoning | Prevents cost surprises; Flash handles 80% of use cases at 10x lower cost |
+| Multi-target deployment | Generate configs for Cloud Run, Firebase Functions, and Agent Engine | Different deployment targets suit different flow types; developers choose |
+| Language adaptation | Transform patterns to TypeScript, Python, or Go | Each repo has language-specific conventions; adapt rather than translate literally |
+| IaC inclusion | Terraform templates alongside application code | Production deployments need reproducible infrastructure, not just application code |
+
+## Tool Usage Pattern
+
+| Tool | Purpose |
+|------|---------|
+| Read | Inspect existing project files, requirements, and configuration to adapt examples to the user's codebase |
+| Write | Create new application files, deployment configs, Terraform modules, and environment templates |
+| Edit | Patch existing code to integrate GCP patterns, update dependencies, or add monitoring |
+| Grep | Search for existing framework usage, import patterns, and configuration in the target project |
+| Glob | Discover project structure to determine where generated code should be placed |
+| Bash(cmd:*) | Run dependency installation, gcloud commands, firebase CLI, and validation scripts |
+
+## Error Handling Strategy
+
+| Error Class | Detection | Recovery |
+|------------|-----------|----------|
+| Framework mismatch | User request doesn't clearly map to a single category | Ask clarifying questions; present the two closest matches with trade-offs |
+| API not enabled | `gcloud services list` missing required APIs | Provide the exact `gcloud services enable` command for each missing API |
+| Region unavailability | Requested model not available in specified region | Suggest `us-central1` or `europe-west4` where Gemini models are available |
+| Dependency conflict | Incompatible SDK versions in existing project | Pin versions explicitly; provide a clean `requirements.txt` or `package.json` |
+| Quota exceeded | Rate limit on Vertex AI prediction endpoints | Include exponential backoff in generated code; provide quota increase request link |
+
+## Extension Points
+
+- Additional framework categories: add new GCP AI repos (e.g., MLOps pipelines) as they become official
+- Language expansion: extend beyond TypeScript/Python/Go when Genkit or ADK adds language support
+- Custom security profiles: allow enterprise users to specify compliance frameworks (SOC2, HIPAA) for stricter defaults
+- Cost calculator integration: generate detailed cost projections based on expected query volume and model selection
+- Template versioning: pin examples to specific SDK versions with automated upgrade paths
+- Interactive selection: when multiple frameworks match, present a comparison table for the user to choose
+- Batch generation: create examples for multiple frameworks from a single requirements document

package/skills/gcp-examples-expert/references/PRD.md

@@ -0,0 +1,68 @@
+# PRD: GCP Examples Expert
+
+**Version:** 2.1.0
+**Author:** Jeremy Longshore <jeremy@intentsolutions.io>
+**Status:** Active
+**Marketplace:** [tonsofskills.com](https://tonsofskills.com) by [Intent Solutions](https://intentsolutions.io)
+**Portfolio:** [jeremylongshore.com](https://jeremylongshore.com)
+
+---
+
+## Problem Statement
+
+Google Cloud's AI ecosystem spans six major frameworks (ADK, Agent Starter Pack, Genkit, Vertex AI, Generative AI, AgentSmithy), each with its own repository, patterns, and deployment targets. Developers waste hours searching through scattered repos to find the right starting code for their use case, then spend more time adapting examples that lack security, monitoring, and production deployment configuration. The gap between "hello world" examples and production-ready code causes teams to ship insecure or unmonitored AI applications.
+
+## Target Users
+
+| User | Context | Primary Need |
+|------|---------|-------------|
+| AI Engineer | Starting a new GCP AI project and unsure which framework to use | Framework selection guidance with a production-ready code example |
+| Backend Developer | Implementing a specific pattern (RAG, agent, multimodal) on GCP | Working code adapted from the correct official repository with deployment config |
+| Solutions Architect | Evaluating GCP AI services for an enterprise deployment | Comprehensive example with security (IAM, VPC-SC), monitoring, and cost estimates |
+| DevOps Engineer | Setting up deployment pipelines for GCP AI applications | Terraform/IaC templates with deployment configuration for Cloud Run or Agent Engine |
+
+## Success Criteria
+
+1. Map any GCP AI request to the correct source repository and code pattern within the first response
+2. Generated examples include IAM least-privilege, Secret Manager for credentials, and monitoring instrumentation
+3. Every example includes a deployment configuration for at least one target (Cloud Run, Firebase Functions, or Agent Engine)
+4. Source repository and official documentation links are cited for every pattern used
+5. Generated code uses currently available Gemini models (2.5 Flash/Pro), not deprecated versions
+6. Environment variable template provided listing all required secrets and API keys
+
+## Functional Requirements
+
+1. Identify the target framework by matching the request to one of six categories: ADK agents, Agent Starter Pack, Genkit flows, Vertex AI training, Generative AI multimodal, or AgentSmithy orchestration
+2. Select the appropriate source repository and code pattern from the categorized reference
+3. Adapt the template to the specified programming language (TypeScript, Python, or Go)
+4. Configure security: IAM least-privilege service accounts, VPC Service Controls, Model Armor
+5. Add monitoring: Cloud Monitoring dashboards, alerting policies, structured logging, OpenTelemetry
+6. Set auto-scaling parameters with min/max instance counts for the deployment target
+7. Include cost optimization: model selection rationale, token estimates, caching strategy
+8. Generate deployment configuration for the target platform
+9. Provide Terraform or IaC templates for reproducible infrastructure provisioning
+10. Cite the source repository and link to official documentation
+
+## Non-Functional Requirements
+
+- All generated code must be runnable without modification (given correct credentials and project setup)
+- API keys and credentials must use Secret Manager references, never inline values
+- Examples must target currently available Gemini models (2.5 Flash/Pro), not deprecated versions
+- Code must follow the style conventions of the source repository it's adapted from
+
+## Dependencies
+
+- Google Cloud project with billing enabled and Vertex AI API activated
+- `gcloud` CLI authenticated with appropriate IAM roles
+- Node.js 18+ for Genkit/TypeScript examples or Python 3.10+ for ADK/Vertex AI examples
+- Firebase CLI for Genkit deployments
+- API keys or service account credentials configured via Secret Manager
+
+## Out of Scope
+
+- Running or executing the generated code (the skill produces code, not executions)
+- Non-Google Cloud platforms (AWS SageMaker, Azure AI)
+- Custom model training or fine-tuning workflows
+- Frontend or UI development for AI applications
+- Ongoing maintenance or version updates of generated examples
+- Proprietary or non-open-source GCP patterns

package/skills/gcp-examples-expert/references/best-practices-applied.md

@@ -0,0 +1,38 @@
+# Best Practices Applied
+
+## Best Practices Applied
+
+### Security
+✅ IAM least privilege service accounts
+✅ VPC Service Controls for enterprise isolation
+✅ Model Armor for prompt injection protection
+✅ Encrypted data at rest and in transit
+✅ No hardcoded credentials (use Secret Manager)
+
+### Performance
+✅ Auto-scaling configuration (min/max instances)
+✅ Appropriate machine types and accelerators
+✅ Caching strategies for repeated queries
+✅ Batch processing for high throughput
+✅ Token optimization for cost efficiency
+
+### Observability
+✅ Cloud Monitoring dashboards
+✅ Alerting policies for errors and latency
+✅ Structured logging with severity levels
+✅ Distributed tracing with Cloud Trace
+✅ Error tracking with Cloud Error Reporting
+
+### Reliability
+✅ Multi-region deployment for high availability
+✅ Circuit breaker patterns for fault tolerance
+✅ Retry logic with exponential backoff
+✅ Health check endpoints
+✅ Graceful degradation strategies
+
+### Cost Optimization
+✅ Use Gemini 2.5 Flash for simple tasks (cheaper)
+✅ Gemini 2.5 Pro for complex reasoning (higher quality)
+✅ Batch predictions for bulk processing
+✅ Preemptible instances for non-critical workloads
+✅ Token counting to estimate costs

package/skills/gcp-examples-expert/references/code-example-categories.md

@@ -0,0 +1,160 @@
+# Code Example Categories
+
+## Code Example Categories
+
+### 1. ADK (Agent Development Kit) Samples
+
+**Source**: google/adk-samples
+
+**Examples Provided**:
+- Basic agent creation with Code Execution Sandbox
+- Memory Bank configuration for stateful agents
+- A2A protocol implementation for inter-agent communication
+- Multi-tool agent configuration
+- VPC Service Controls integration
+- IAM least privilege patterns
+
+**Sample Pattern**:
+```python
+from google.cloud.aiplatform import agent_builder
+
+def create_adk_agent(project_id: str, location: str):
+    agent_config = {
+        "display_name": "production-agent",
+        "model": "gemini-2.5-flash",
+        "code_execution_config": {
+            "enabled": True,
+            "state_ttl_days": 14
+        },
+        "memory_bank_config": {
+            "enabled": True
+        }
+    }
+    # Implementation from google/adk-samples
+```
+
+### 2. Agent Starter Pack
+
+**Source**: GoogleCloudPlatform/agent-starter-pack
+
+**Examples Provided**:
+- Production agent with monitoring and observability
+- Auto-scaling configuration
+- Security best practices (Model Armor, VPC-SC)
+- Cloud Monitoring dashboards
+- Alerting policies
+- Error tracking setup
+
+**Sample Pattern**:
+```python
+def production_agent_with_observability(project_id: str):
+    agent = aiplatform.Agent.create(
+        config={
+            "auto_scaling": {
+                "min_instances": 2,
+                "max_instances": 10
+            },
+            "vpc_service_controls": {"enabled": True},
+            "model_armor": {"enabled": True}
+        }
+    )
+    # Full implementation from agent-starter-pack
+```
+
+### 3. Firebase Genkit
+
+**Source**: genkit-ai/genkit
+
+**Examples Provided**:
+- RAG flows with vector search
+- Multi-step workflows
+- Tool calling integration
+- Prompt templates
+- Evaluation frameworks
+- Deployment patterns (Cloud Run, Functions)
+
+**Sample Pattern**:
+```typescript
+import { genkit, z } from 'genkit';
+import { googleAI, gemini15ProLatest } from '@genkit-ai/googleai';
+
+const ragFlow = ai.defineFlow({
+  name: 'ragSearchFlow',
+  inputSchema: z.object({ query: z.string() }),
+  outputSchema: z.object({ answer: z.string() })
+}, async (input) => {
+  // Implementation from genkit-ai/genkit examples
+});
+```
+
+### 4. Vertex AI Samples
+
+**Source**: GoogleCloudPlatform/vertex-ai-samples
+
+**Examples Provided**:
+- Custom model training with Gemini
+- Batch prediction jobs
+- Hyperparameter tuning
+- Model evaluation
+- Endpoint deployment with auto-scaling
+- A/B testing patterns
+
+**Sample Pattern**:
+```python
+def fine_tune_gemini_model(project_id: str, training_data_uri: str):
+    job = aiplatform.CustomTrainingJob(
+        training_config={
+            "base_model": "gemini-2.5-flash",
+            "learning_rate": 0.001,
+            "adapter_size": 8  # LoRA
+        }
+    )
+    # Full implementation from vertex-ai-samples
+```
+
+### 5. Generative AI Examples
+
+**Source**: GoogleCloudPlatform/generative-ai
+
+**Examples Provided**:
+- Gemini multimodal analysis (text, images, video)
+- Function calling with live APIs
+- Structured output generation
+- Grounding with Google Search
+- Safety filters and content moderation
+- Token counting and cost optimization
+
+**Sample Pattern**:
+```python
+from vertexai.generative_models import GenerativeModel, Part
+
+def analyze_multimodal_content(video_uri: str, question: str):
+    model = GenerativeModel("gemini-2.5-pro")
+    video_part = Part.from_uri(video_uri, mime_type="video/mp4")
+    response = model.generate_content([video_part, question])
+    # Implementation from generative-ai examples
+```
+
+### 6. AgentSmithy
+
+**Source**: GoogleCloudPlatform/agentsmithy
+
+**Examples Provided**:
+- Multi-agent orchestration
+- Supervisory agent patterns
+- Agent-to-agent communication
+- Workflow coordination (sequential, parallel, conditional)
+- Task delegation strategies
+- Error handling and retry logic
+
+**Sample Pattern**:
+```python
+from agentsmithy import Agent, Orchestrator, Task
+
+def create_multi_agent_system(project_id: str):
+    orchestrator = Orchestrator(
+        agents=[research_agent, analysis_agent, writer_agent],
+        strategy="sequential"
+    )
+    # Full implementation from agentsmithy
+```

package/skills/gcp-examples-expert/references/errors.md

@@ -0,0 +1,54 @@
+# Error Handling Reference
+
+## Authentication & Authorization
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| `UNAUTHENTICATED: Request had invalid authentication credentials` | ADC not configured or expired token | Run `gcloud auth application-default login`; verify `GOOGLE_APPLICATION_CREDENTIALS` env var points to a valid service account key |
+| `PERMISSION_DENIED: caller does not have permission` | Service account missing required IAM roles | Grant `roles/aiplatform.user` for Vertex AI, `roles/run.developer` for Cloud Run; use `gcloud projects get-iam-policy` to audit bindings |
+| `PERMISSION_DENIED: VPC Service Controls` | Request originates outside the VPC-SC perimeter | Add the caller's IP or access level to the perimeter; check `gcloud access-context-manager perimeters describe` |
+
+## API & Quota
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| `API [aiplatform.googleapis.com] not enabled` | Vertex AI API disabled on the project | Run `gcloud services enable aiplatform.googleapis.com` |
+| `RESOURCE_EXHAUSTED: quota exceeded` | Rate limit or daily token quota hit | Request quota increase via Cloud Console; implement exponential backoff with jitter; consider batching requests |
+| `429 Too Many Requests` | Gemini API rate-limited | Back off and retry; use `google-cloud-aiplatform` client library (auto-retries); switch lower-priority tasks to Gemini Flash |
+
+## Model & Region
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| `Model not found: gemini-2.5-pro` | Model not available in the specified region | Use `us-central1` or `europe-west4` where Gemini 2.5 models are generally available; check [regional availability docs](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations) |
+| `INVALID_ARGUMENT: unsupported model` | Using deprecated model name or wrong model ID | Verify model ID format: `gemini-2.5-pro`, `gemini-2.5-flash`; avoid legacy names like `gemini-1.0-pro` |
+| `SAFETY_BLOCK` in response | Model safety filters triggered | Review prompt for policy violations; adjust safety settings if appropriate; add input sanitization layer |
+
+## Dependency & Build
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| `ModuleNotFoundError: No module named 'google.adk'` | ADK package not installed | Run `pip install google-adk`; verify virtual environment is activated |
+| `Cannot find module '@genkit-ai/googleai'` | Genkit Google AI plugin not installed | Run `npm install @genkit-ai/googleai`; check `package.json` has correct version |
+| `Version conflict` between AI SDK packages | Incompatible pinned versions | Pin all `@genkit-ai/*` packages to the same minor version; use lockfile (`package-lock.json` or `pnpm-lock.yaml`) |
+| `ImportError: cannot import name 'Agent' from 'google.adk'` | Wrong import path for ADK Agent class | Use `from google.adk.agents import Agent` (not `from google.adk import Agent`) |
+
+## Deployment
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| `Cloud Run: Container failed to start` | Missing env vars or port misconfiguration | Ensure `PORT=8080` is set; verify `GOOGLE_GENAI_API_KEY` or credentials are passed via `--set-secrets` |
+| `Cloud Run: Memory limit exceeded` | Container OOM during model inference | Increase memory with `--memory 1Gi` or higher; reduce batch sizes; use streaming responses |
+| `Terraform: Error creating Agent` | Terraform provider version incompatible | Upgrade `hashicorp/google` provider to `~> 5.0`; run `terraform init -upgrade` |
+| `adk deploy: timeout` | Large agent package or slow network | Increase timeout; verify `.gcloudignore` excludes `node_modules`, `venv`, and test data |
+
+## Runtime
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| `Timeout: request took longer than 300s` | Complex prompt or large context window | Reduce context size; use Gemini Flash for simple tasks; implement streaming for long generations |
+| `INVALID_ARGUMENT: request payload too large` | Input exceeds model context limit | Chunk large documents; summarize before sending; use RAG to retrieve only relevant sections |
+| `JSONDecodeError` when parsing structured output | Model returned non-JSON despite `response_mime_type: application/json` | Add explicit JSON schema in prompt; retry with lower temperature; validate output before parsing |
+
+---
+*[Tons of Skills](https://tonsofskills.com) by [Intent Solutions](https://intentsolutions.io) | [jeremylongshore.com](https://jeremylongshore.com)*

package/skills/gcp-examples-expert/references/example-interactions.md

@@ -0,0 +1,53 @@
+# Example Interactions
+
+## Example Interactions
+
+### Example 1: ADK Agent Creation
+**User**: "Show me how to create an ADK agent with Code Execution"
+
+**Skill Activates**:
+- Provides code example from google/adk-samples
+- Includes Code Execution Sandbox configuration
+- Shows 14-day state persistence setup
+- Demonstrates security best practices
+- Links to official ADK documentation
+
+### Example 2: Genkit RAG Flow
+**User**: "I need a Genkit starter template for RAG"
+
+**Skill Activates**:
+- Provides RAG flow code from genkit-ai/genkit
+- Shows vector search integration
+- Demonstrates embedding generation
+- Includes context retrieval logic
+- Provides deployment configuration
+
+### Example 3: Production Agent Template
+**User**: "What's the best way to deploy a production agent?"
+
+**Skill Activates**:
+- Provides Agent Starter Pack template
+- Shows auto-scaling configuration
+- Includes monitoring dashboard setup
+- Demonstrates alerting policies
+- Provides Terraform deployment code
+
+### Example 4: Gemini Multimodal
+**User**: "How do I analyze video with Gemini?"
+
+**Skill Activates**:
+- Provides multimodal code from generative-ai repo
+- Shows video part creation
+- Demonstrates prompt engineering
+- Includes error handling
+- Provides cost optimization tips
+
+### Example 5: Multi-Agent System
+**User**: "I want to build a multi-agent system"
+
+**Skill Activates**:
+- Provides AgentSmithy orchestration code
+- Shows supervisory agent pattern
+- Demonstrates A2A protocol usage
+- Includes workflow coordination
+- Provides testing strategies