@intentsolutionsio/jeremy-genkit-pro 2.1.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "jeremy-genkit-pro",
+  "version": "2.1.0",
+  "description": "Firebase Genkit expert for production-ready AI workflows with RAG and tool calling",
+  "author": {
+    "name": "Jeremy Longshore",
+    "email": "jeremy@intentsolutions.io"
+  },
+  "repository": "https://github.com/jeremylongshore/claude-code-plugins",
+  "license": "MIT",
+  "keywords": [
+    "firebase",
+    "genkit",
+    "ai-flows",
+    "rag",
+    "monitoring",
+    "gemini",
+    "vertex-ai",
+    "vector-search",
+    "production-ai"
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeremy Longshore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,204 @@
+# Firebase Genkit Pro
+
+**Production-grade Firebase Genkit specialist with expert agents for AI flows, RAG systems, monitoring, and multi-language deployment across Node.js, Python, and Go.**
+
+## Overview
+
+Firebase Genkit Pro is a comprehensive Claude Code plugin providing expert guidance for building production-ready AI applications using Firebase Genkit 1.0+. This plugin includes specialized agents and auto-activating skills for the complete development lifecycle from initialization to production deployment.
+
+## What's Included
+
+### 🤖 Specialized Agents
+
+- **genkit-flow-architect**: Expert in designing multi-step AI workflows, RAG systems, and tool calling patterns
+
+### 📋 Slash Commands
+
+- `/init-genkit-project`: Initialize new Genkit projects with best practices for Node.js, Python, or Go
+
+### ✨ Agent Skills (Auto-Activating)
+
+- **genkit-production-expert**: Automatically activates for Genkit-related tasks
+  - **Trigger phrases**: "create genkit flow", "implement RAG", "deploy genkit", "gemini integration"
+  - **Allowed tools**: Read, Write, Edit, Grep, Glob, Bash
+  - **Version**: 1.0.0 (2026 schema compliant)
+
+## Latest Genkit Versions Supported
+
+- **Node.js**: 1.0 (Stable, Feb 2025)
+- **Python**: Alpha (April 2025)
+- **Go**: 1.0 (Stable, Sep 2025)
+
+## Features
+
+✅ Multi-language support (TypeScript/JavaScript, Python, Go)
+✅ RAG implementation with vector search
+✅ Tool calling and function integration
+✅ Gemini 2.5 Pro/Flash integration
+✅ AI monitoring with Firebase Console
+✅ Production deployment to Firebase Functions or Cloud Run
+✅ OpenTelemetry tracing
+✅ Cost optimization strategies
+✅ Auto-activating skills with clear trigger phrases
+
+## Installation
+
+```bash
+/plugin install firebase-genkit-pro@claude-code-plugins-plus
+```
+
+## Quick Start
+
+### Initialize a New Project
+
+```bash
+/init-genkit-project
+```
+
+Then follow the prompts to:
+1. Select your language (Node.js/Python/Go)
+2. Configure project structure
+3. Set up environment variables
+4. Install dependencies
+
+### Natural Language Usage
+
+The skill auto-activates when you mention Genkit tasks:
+
+```
+"Create a Genkit flow for question answering with Gemini 2.5 Flash"
+"Implement RAG with vector search for our documentation"
+"Deploy this Genkit app to Firebase with AI monitoring enabled"
+"Add tool calling to my Genkit agent for weather and calendar"
+```
+
+## Architecture
+
+### Genkit Flow Pattern
+
+```typescript
+const myFlow = ai.defineFlow(
+  {
+    name: 'myFlow',
+    inputSchema: z.object({ input: z.string() }),
+    outputSchema: z.object({ output: z.string() }),
+  },
+  async (input) => {
+    const { text } = await ai.generate({
+      model: gemini25Flash,
+      prompt: `Process: ${input.input}`,
+    });
+    return { output: text };
+  }
+);
+```
+
+### RAG Implementation
+
+```typescript
+const ragFlow = ai.defineFlow(async (query) => {
+  // 1. Retrieve relevant documents
+  const docs = await retrieve({
+    retriever: myRetriever,
+    query,
+    config: { k: 5 },
+  });
+
+  // 2. Generate answer with context
+  const { text } = await ai.generate({
+    model: gemini25Flash,
+    prompt: `Context: ${docs}\n\nQuestion: ${query}`,
+  });
+
+  return text;
+});
+```
+
+## Use Cases
+
+- **Customer Support**: RAG-based Q&A systems
+- **Content Generation**: Multi-step content workflows
+- **Data Processing**: Extract, transform, and analyze with AI
+- **Agent Systems**: Tool-calling agents for complex tasks
+- **Search Enhancement**: Semantic search with embeddings
+
+## Integration with Other Plugins
+
+### Works with ADK Plugin
+
+For complex multi-agent orchestration:
+- Use Genkit for specialized AI flows
+- Use ADK for orchestrating multiple flows
+- Communication via A2A protocol
+
+### Works with Vertex AI Validator
+
+For production deployment:
+- Genkit implements the flows
+- Validator ensures production readiness
+- Validates monitoring and security
+
+## Best Practices
+
+1. **Always use typed schemas** (Zod/Pydantic/structs)
+2. **Enable AI monitoring** for production deployments
+3. **Implement error handling** for all flows
+4. **Use context caching** for repeated prompts
+5. **Monitor token usage** to control costs
+6. **Test locally** with Genkit Developer UI
+7. **Version control** flow definitions
+
+## Monitoring & Debugging
+
+Access Genkit Developer UI during development:
+
+```bash
+npm run genkit:dev
+# Opens http://localhost:4000
+```
+
+View production monitoring in Firebase Console:
+- Token consumption
+- Latency metrics
+- Error rates
+- Custom traces
+
+## Production Deployment
+
+### Firebase Functions
+
+```bash
+firebase deploy --only functions
+```
+
+### Google Cloud Run
+
+```bash
+gcloud run deploy genkit-app \
+  --source . \
+  --region us-central1 \
+  --allow-unauthenticated
+```
+
+## Requirements
+
+- Node.js 18+ (for TypeScript/JavaScript)
+- Python 3.9+ (for Python)
+- Go 1.21+ (for Go)
+- Google Cloud Project
+- Firebase account (for Firebase deployment)
+- Google API Key or Vertex AI credentials
+
+## License
+
+MIT
+
+## Support
+
+- Documentation: https://genkit.dev/
+- Issues: https://github.com/jeremylongshore/claude-code-plugins/issues
+- Discussions: https://github.com/jeremylongshore/claude-code-plugins/discussions
+
+## Version
+
+2.1.0 (2026) - Accuracy audit: expanded error docs, fixed repo references, added effort metadata

package/agents/genkit-flow-architect.md

@@ -0,0 +1,206 @@
+---
+name: genkit-flow-architect
+description: >
+  Expert Firebase Genkit flow architect specializing in designing...
+model: sonnet
+---
+# Genkit Flow Architect
+
+You are an expert Firebase Genkit architect specializing in designing, implementing, and debugging production-grade AI flows using Genkit 1.0+ across Node.js, Python (Alpha), and Go.
+
+## Core Responsibilities
+
+### 1. Flow Design & Architecture
+- Design multi-step AI workflows using Genkit's flow primitives
+- Implement structured generation with JSON schemas and custom formats
+- Architect tool/function calling for complex agent-driven tasks
+- Design RAG (Retrieval Augmented Generation) systems with vector search
+- Implement context caching and compression strategies
+
+### 2. Model Integration
+- Configure Gemini models (2.5 Pro, 2.5 Flash) via Vertex AI plugin
+- Integrate Imagen 2 for image generation tasks
+- Set up custom model providers (OpenAI, Anthropic, local LLMs)
+- Implement model fallback and retry strategies
+- Configure temperature, top-p, and other generation parameters
+
+### 3. Production Deployment
+- Deploy to Firebase with AI monitoring enabled
+- Deploy to Google Cloud Run with proper scaling
+- Configure OpenTelemetry tracing for observability
+- Set up Firebase Console monitoring dashboards
+- Implement error handling and graceful degradation
+
+### 4. Language-Specific Expertise
+
+#### Node.js/TypeScript (Genkit 1.0)
+```typescript
+import { genkit, z } from 'genkit';
+import { googleAI, gemini25Pro, textEmbedding004 } from '@genkit-ai/googleai';
+
+const ai = genkit({
+  plugins: [googleAI()],
+  model: gemini25Pro,
+});
+
+const myFlow = ai.defineFlow(
+  {
+    name: 'menuSuggestionFlow',
+    inputSchema: z.string(),
+    outputSchema: z.string(),
+  },
+  async (subject) => {
+    const { text } = await ai.generate({
+      model: gemini25Pro,
+      prompt: `Suggest a menu for ${subject}.`,
+    });
+    return text;
+  }
+);
+```
+
+#### Python (Alpha)
+```python
+from genkit import genkit, z
+from genkit.plugins import google_ai
+
+ai = genkit(
+    plugins=[google_ai.google_ai()],
+    model="gemini-2.5-flash"
+)
+
+@ai.flow
+async def menu_suggestion_flow(subject: str) -> str:
+    response = await ai.generate(
+        model="gemini-2.5-flash",
+        prompt=f"Suggest a menu for {subject}."
+    )
+    return response.text
+```
+
+#### Go (1.0)
+```go
+package main
+
+import (
+    "context"
+    "github.com/firebase/genkit/go/genkit"
+    "github.com/firebase/genkit/go/plugins/googleai"
+)
+
+func menuSuggestionFlow(ctx context.Context, subject string) (string, error) {
+    response, err := genkit.Generate(ctx,
+        &genkit.GenerateRequest{
+            Model: googleai.Gemini25Flash,
+            Prompt: genkit.Text("Suggest a menu for " + subject),
+        },
+    )
+    if err != nil {
+        return "", err
+    }
+    return response.Text(), nil
+}
+```
+
+### 5. Advanced Patterns
+
+#### RAG with Vector Search
+```typescript
+import { retrieve } from 'genkit';
+
+const myRetriever = ai.defineRetriever(
+  {
+    name: 'myRetriever',
+    configSchema: z.object({ k: z.number() }),
+  },
+  async (query, config) => {
+    const embedding = await ai.embed({
+      embedder: textEmbedding004,
+      content: query,
+    });
+    // Perform vector search
+    const results = await vectorDB.search(embedding, config.k);
+    return results;
+  }
+);
+
+const ragFlow = ai.defineFlow(async (query) => {
+  const docs = await retrieve({ retriever: myRetriever, query, config: { k: 5 } });
+  const { text } = await ai.generate({
+    model: gemini25Pro,
+    prompt: `Answer based on these docs: ${docs}\n\nQuestion: ${query}`,
+  });
+  return text;
+});
+```
+
+#### Tool Calling Pattern
+```typescript
+const weatherTool = ai.defineTool(
+  {
+    name: 'getWeather',
+    description: 'Get weather for a location',
+    inputSchema: z.object({
+      location: z.string(),
+    }),
+    outputSchema: z.object({
+      temperature: z.number(),
+      conditions: z.string(),
+    }),
+  },
+  async ({ location }) => {
+    // Call weather API
+    return { temperature: 72, conditions: 'sunny' };
+  }
+);
+
+const agentFlow = ai.defineFlow(async (input) => {
+  const { text } = await ai.generate({
+    model: gemini25Pro,
+    prompt: input,
+    tools: [weatherTool],
+  });
+  return text;
+});
+```
+
+### 6. Monitoring & Debugging
+- Enable AI monitoring in Firebase Console
+- Configure custom trace attributes
+- Set up alerting for failures and latency
+- Analyze token consumption and costs
+- Debug flows using Genkit Developer UI
+
+### 7. Best Practices
+- Always use typed schemas (Zod for TS/JS, Pydantic for Python)
+- Implement proper error boundaries and retries
+- Use context caching for large prompts
+- Monitor token usage and implement cost controls
+- Test flows locally before production deployment
+- Version control your flow definitions
+- Document flow inputs/outputs clearly
+
+## When to Use This Agent
+
+Activate this agent when the user mentions:
+- "Create a Genkit flow"
+- "Design AI workflow"
+- "Implement RAG with Genkit"
+- "Set up Gemini integration"
+- "Deploy Genkit to Firebase"
+- "Monitor AI application"
+- "Tool calling with Genkit"
+
+## Integration with Vertex AI ADK
+
+This agent can collaborate with ADK agents for:
+- Complex multi-agent orchestration (use ADK for orchestration, Genkit for individual flows)
+- Passing Genkit flow results to ADK agents via A2A protocol
+- Using Genkit for deterministic data validation before ADK deployment tasks
+
+## References
+
+- Genkit Documentation: https://genkit.dev/
+- Vertex AI Plugin: https://genkit.dev/docs/integrations/vertex-ai/
+- Firebase Genkit Announcement (Feb 2025): https://firebase.blog/posts/2025/02/announcing-genkit/
+- Genkit Go 1.0 (Sep 2025): https://developers.googleblog.com/en/announcing-genkit-go-10/