步骤 4：配置 API 密钥

# Google AI (Gemini)
export GEMINI_API_KEY=your_key_here

# OpenAI
export OPENAI_API_KEY=your_key_here

# Anthropic
export ANTHROPIC_API_KEY=your_key_here

核心概念

初始化 Genkit

import { googleAI } from '@genkit-ai/google-genai';
import { genkit } from 'genkit';

const ai = genkit({
  plugins: [googleAI()],
  model: googleAI.model('gemini-2.5-flash'), // 默认模型
});

定义流

流是核心原语：类型安全、可观测、可部署的 AI 函数。

import { genkit, z } from 'genkit';
import { googleAI } from '@genkit-ai/google-genai';

const ai = genkit({ plugins: [googleAI()] });

// 使用 Zod 定义输入/输出模式
const SummaryInputSchema = z.object({
  text: z.string().describe('要总结的文本'),
  maxWords: z.number().optional().default(100),
});

const SummaryOutputSchema = z.object({
  summary: z.string(),
  keyPoints: z.array(z.string()),
});

export const summarizeFlow = ai.defineFlow(
  {
    name: 'summarizeFlow',
    inputSchema: SummaryInputSchema,
    outputSchema: SummaryOutputSchema,
  },
  async ({ text, maxWords }) => {
    const { output } = await ai.generate({
      model: googleAI.model('gemini-2.5-flash'),
      prompt: `用最多 ${maxWords} 个词总结以下文本并提取要点：\n\n${text}`,
      output: { schema: SummaryOutputSchema },
    });

    if (!output) throw new Error('未生成输出');
    return output;
  }
);

// 调用流
const result = await summarizeFlow({
  text: '长文章内容在这里...',
  maxWords: 50,
});
console.log(result.summary);

生成内容

// 简单文本生成
const { text } = await ai.generate({
  model: googleAI.model('gemini-2.5-flash'),
  prompt: '用一句话解释量子计算。',
});

// 结构化输出
const { output } = await ai.generate({
  prompt: '列出 3 种编程语言及其用例',
  output: {
    schema: z.object({
      languages: z.array(z.object({
        name: z.string(),
        useCase: z.string(),
      })),
    }),
  },
});

// 使用系统提示词
const { text: response } = await ai.generate({
  system: '你是一名资深的 TypeScript 工程师。请简明扼要。',
  prompt: 'TypeScript 中 interface 和 type 有什么区别？',
});

// 多模态（图像 + 文本）
const { text: description } = await ai.generate({
  prompt: [
    { text: '这张图片里有什么？' },
    { media: { url: 'https://example.com/image.jpg', contentType: 'image/jpeg' } },
  ],
});

流式流

export const streamingFlow = ai.defineFlow(
  {
    name: 'streamingFlow',
    inputSchema: z.object({ topic: z.string() }),
    streamSchema: z.string(),        // 每个数据块的类型
    outputSchema: z.object({ full: z.string() }),
  },
  async ({ topic }, { sendChunk }) => {
    const { stream, response } = ai.generateStream({
      prompt: `写一篇关于 ${topic} 的详细文章。`,
    });

    for await (const chunk of stream) {
      sendChunk(chunk.text);         // 将每个令牌流式传输到客户端
    }

    const { text } = await response;
    return { full: text };
  }
);

// 客户端消费
const stream = streamingFlow.stream({ topic: 'AI 伦理' });
for await (const chunk of stream.stream) {
  process.stdout.write(chunk);
}
const finalOutput = await stream.output;

工具调用（智能体）

import { z } from 'genkit';

// 定义工具
const getWeatherTool = ai.defineTool(
  {
    name: 'getWeather',
    description: '获取城市的当前天气',
    inputSchema: z.object({ city: z.string() }),
    outputSchema: z.object({ temp: z.number(), condition: z.string() }),
  },
  async ({ city }) => {
    // 调用真实的天气 API
    return { temp: 22, condition: 'sunny' };
  }
);

const searchWebTool = ai.defineTool(
  {
    name: 'searchWeb',
    description: '在网络上搜索信息',
    inputSchema: z.object({ query: z.string() }),
    outputSchema: z.string(),
  },
  async ({ query }) => {
    // 调用搜索 API
    return `搜索查询结果：${query}`;
  }
);

// 带有工具的智能体流
export const agentFlow = ai.defineFlow(
  {
    name: 'agentFlow',
    inputSchema: z.object({ question: z.string() }),
    outputSchema: z.string(),
  },
  async ({ question }) => {
    const { text } = await ai.generate({
      prompt: question,
      tools: [getWeatherTool, searchWebTool],
      returnToolRequests: false, // 自动执行工具
    });
    return text;
  }
);

使用 Dotprompt 管理提示词

将提示词作为版本化的 .prompt 文件进行管理：

# src/prompts/summarize.prompt
---
model: googleai/gemini-2.5-flash
input:
  schema:
    text: string
    style?: string
output:
  schema:
    summary: string
    sentiment: string
---
用 {{style, default: "professional"}} 的语气总结以下文本：

{{text}}

返回包含 summary 和 sentiment (positive/negative/neutral) 的 JSON。



// 加载并使用 dotprompt
const summarizePrompt = ai.prompt('summarize');
const { output } = await summarizePrompt({
  text: '文章内容在这里...',
  style: 'casual',
});

RAG — 检索增强生成

import { devLocalVectorstore } from '@genkit-ai/dev-local-vectorstore';
import { textEmbedding004 } from '@genkit-ai/google-genai';

const ai = genkit({
  plugins: [
    googleAI(),
    devLocalVectorstore([{
      indexName: 'documents',
      embedder: textEmbedding004,
    }]),
  ],
});

// 索引文档
await ai.index({
  indexer: devLocalVectorstoreIndexer('documents'),
  docs: [
    { content: [{ text: '文档 1 内容...' }], metadata: { source: 'doc1' } },
    { content: [{ text: '文档 2 内容...' }], metadata: { source: 'doc2' } },
  ],
});

// RAG 流
export const ragFlow = ai.defineFlow(
  {
    name: 'ragFlow',
    inputSchema: z.object({ question: z.string() }),
    outputSchema: z.string(),
  },
  async ({ question }) => {
    // 检索相关文档
    const docs = await ai.retrieve({
      retriever: devLocalVectorstoreRetriever('documents'),
      query: question,
      options: { k: 3 },
    });

    // 基于检索到的文档生成答案
    const { text } = await ai.generate({
      system: '仅使用提供的上下文回答问题。',
      prompt: question,
      docs,
    });

    return text;
  }
);

聊天会话

export const chatFlow = ai.defineFlow(
  {
    name: 'chatFlow',
    inputSchema: z.object({ message: z.string(), sessionId: z.string() }),
    outputSchema: z.string(),
  },
  async ({ message, sessionId }) => {
    const session = ai.loadSession(sessionId) ?? ai.createSession({ sessionId });
    const chat = session.chat({
      system: '你是一个乐于助人的助手。',
    });

    const { text } = await chat.send(message);
    return text;
  }
);

多智能体系统

// 专家智能体
const researchAgent = ai.defineFlow(
  { name: 'researchAgent', inputSchema: z.string(), outputSchema: z.string() },
  async (query) => {
    const { text } = await ai.generate({
      system: '你是一名研究专家。收集事实并引用来源。',
      prompt: query,
      tools: [searchWebTool],
    });
    return text;
  }
);

const writerAgent = ai.defineFlow(
  { name: 'writerAgent', inputSchema: z.string(), outputSchema: z.string() },
  async (brief) => {
    const { text } = await ai.generate({
      system: '你是一名专业作家。撰写清晰、引人入胜的内容。',
      prompt: brief,
    });
    return text;
  }
);

// 协调器委托给专家
export const contentPipelineFlow = ai.defineFlow(
  {
    name: 'contentPipelineFlow',
    inputSchema: z.object({ topic: z.string() }),
    outputSchema: z.string(),
  },
  async ({ topic }) => {
    const research = await researchAgent(`研究：${topic}`);
    const article = await writerAgent(`基于以下内容撰写文章：${research}`);
    return article;
  }
);

开发者工具

CLI 命令

# 启动开发者 UI 并连接到你的应用
genkit start -- npx tsx --watch src/index.ts
genkit start -o -- npx tsx src/index.ts    # 自动打开浏览器

# 从 CLI 运行特定流
genkit flow:run summarizeFlow '{"text": "Hello world", "maxWords": 10}'

# 运行并流式输出
genkit flow:run streamingFlow '{"topic": "AI"}' -s

# 评估一个流
genkit eval:flow ragFlow --input eval-inputs.json

# 查看所有命令
genkit --help

# 禁用分析遥测
genkit config set analyticsOptOut true

开发者 UI

开发者 UI 运行在 http://localhost:4000 并提供：

• 流运行器：使用自定义 JSON 输入执行流

• 追踪检查器：可视化每个步骤（生成、嵌入、检索、工具调用）

• 提示词游乐场：交互式测试提示词

• 模型测试器：比较不同模型的输出

• 评估器：针对流运行评估数据集

  为方便起见添加 npm 脚本

  package.json

  "scripts": { "genkit:dev": "genkit start -- npx tsx --watch src/index.ts" }

  npm run genkit:dev

部署

Firebase Cloud Functions

import { onCallGenkit } from 'firebase-functions/https';
import { defineSecret } from 'firebase-functions/params';

const apiKey = defineSecret('GOOGLE_AI_API_KEY');

export const summarize = onCallGenkit(
  { secrets: [apiKey] },
  summarizeFlow
);



firebase deploy --only functions

Express.js 服务器

import express from 'express';
import { expressHandler } from 'genkit/express';

const app = express();
app.use(express.json());

app.post('/summarize', expressHandler(summarizeFlow));
app.post('/chat', expressHandler(chatFlow));

app.listen(3000, () => console.log('Server running on port 3000'));

Cloud Run

# 构建并部署
gcloud run deploy genkit-app \
  --source . \
  --region us-central1 \
  --set-env-vars GEMINI_API_KEY=$GEMINI_API_KEY

支持的插件

模型提供商

向量数据库

最佳实践

1. 始终定义输入/输出模式 — 使用 Zod 对象以获得开发者 UI 的标签字段和 API 安全性
2. 对所有 AI 逻辑使用流 — 即使是简单的调用；流可以免费提供追踪和部署功能
3. 将 API 密钥存储在环境变量中 — 切勿硬编码；生产环境使用 Firebase Secrets
4. 使用 ai.run() 来追踪自定义步骤 — 将非 Genkit 代码包装在 ai.run() 中以获得追踪可见性
5. 流式传输长内容 — 使用带有 streamSchema 和 sendChunk 的 defineFlow 以获得更好的用户体验
6. 通过智能体分离关注点 — 专门的子流优于单一的整体流
7. 使用 Dotprompt 进行团队提示词管理 — .prompt 文件支持版本控制、审查和重用

约束

必须做

• 为所有流的输入和输出定义模式
• 处理 generate() 的 null 输出 — 抛出有意义的错误
• 当独立于开发服务器运行流时，设置 GENKIT_ENV=dev
• 部署到 Firebase 时使用 onCallGenkit（而非原始的 Cloud Functions）

禁止做

• 切勿在源代码中硬编码 API 密钥
• 如果需要进行追踪/可观测性，不要在流之外使用 generate()
• 不要在没有命令的情况下调用 genkit start — 总是传递 -- <your-run-command>
• 避免在工具处理程序中阻塞事件循环 — 使用 async/await

参考

• 官方文档
• 入门指南
• 开发者工具
• 流参考
• 工具调用
• RAG 指南
• 多智能体系统
• Dotprompt
• GitHub 仓库
• API 参考

示例

示例 1：最小化流

import { googleAI } from '@genkit-ai/google-genai';
import { genkit, z } from 'genkit';

const ai = genkit({ plugins: [googleAI()] });

export const helloFlow = ai.defineFlow(
  {
    name: 'helloFlow',
    inputSchema: z.object({ name: z.string() }),
    outputSchema: z.string(),
  },
  async ({ name }) => {
    const { text } = await ai.generate(`用一种有创意的方式向 ${name} 问好。`);
    return text;
  }
);

// 运行它
const greeting = await helloFlow({ name: 'World' });
console.log(greeting);

示例 2：完整的 RAG + 智能体流水线

import { googleAI, textEmbedding004 } from '@genkit-ai/google-genai';
import { devLocalVectorstore } from '@genkit-ai/dev-local-vectorstore';
import { genkit, z } from 'genkit';

const ai = genkit({
  plugins: [
    googleAI(),
    devLocalVectorstore([{ indexName: 'kb', embedder: textEmbedding004 }]),
  ],
});

// 索引知识库文档
const indexKnowledgeBase = ai.defineFlow(
  { name: 'indexKB', inputSchema: z.array(z.string()) },
  async (texts) => {
    await ai.index({
      indexer: devLocalVectorstoreIndexer('kb'),
      docs: texts.map(text => ({ content: [{ text }] })),
    });
  }
);

// 使用 RAG 回答问题
export const answerFlow = ai.defineFlow(
  {
    name: 'answerFlow',
    inputSchema: z.object({ question: z.string() }),
    outputSchema: z.object({ answer: z.string(), sources: z.number() }),
  },
  async ({ question }) => {
    const docs = await ai.retrieve({
      retriever: devLocalVectorstoreRetriever('kb'),
      query: question,
      options: { k: 5 },
    });

    const { text } = await ai.generate({
      system: '仅从提供的上下文中回答。如果不确定，请说明。',
      prompt: question,
      docs,
    });

    return { answer: text, sources: docs.length };
  }
);

示例 3：多模型比较

import { googleAI } from '@genkit-ai/google-genai';
import { openAI } from 'genkitx-openai';
import { genkit, z } from 'genkit';

const ai = genkit({ plugins: [googleAI(), openAI()] });

export const compareModelsFlow = ai.defineFlow(
  {
    name: 'compareModelsFlow',
    inputSchema: z.object({ prompt: z.string() }),
    outputSchema: z.object({ gemini: z.string(), gpt4o: z.string() }),
  },
  async ({ prompt }) => {
    const [geminiResult, gptResult] = await Promise.all([
      ai.generate({ model: googleAI.model('gemini-2.5-flash'), prompt }),
      ai.generate({ model: 'openai/gpt-4o', prompt }),
    ]);

    return {
      gemini: geminiResult.text,
      gpt4o: gptResult.text,
    };
  }
);

每周安装数

1

仓库

akillness/oh-my-gods

首次出现

1 天前

安全审计

Gen Agent Trust HubPassSocketWarnSnykWarn

安装于

mcpjam1

claude-code1

replit1

junie1

windsurf1

zencoder1

Step 3: Install Genkit core and a model plugin

# Core + Google AI (Gemini) — free tier, no credit card required
npm install genkit @genkit-ai/google-genai

# Or: Vertex AI (requires GCP project)
npm install genkit @genkit-ai/vertexai

# Or: OpenAI
npm install genkit genkitx-openai

# Or: Anthropic (Claude)
npm install genkit genkitx-anthropic

# Or: Ollama (local models)
npm install genkit genkitx-ollama

Step 4: Configure API Key

# Google AI (Gemini)
export GEMINI_API_KEY=your_key_here

# OpenAI
export OPENAI_API_KEY=your_key_here

# Anthropic
export ANTHROPIC_API_KEY=your_key_here

Core Concepts

Initializing Genkit

import { googleAI } from '@genkit-ai/google-genai';
import { genkit } from 'genkit';

const ai = genkit({
  plugins: [googleAI()],
  model: googleAI.model('gemini-2.5-flash'), // default model
});

Defining Flows

Flows are the core primitive: type-safe, observable, deployable AI functions.

import { genkit, z } from 'genkit';
import { googleAI } from '@genkit-ai/google-genai';

const ai = genkit({ plugins: [googleAI()] });

// Input/output schemas with Zod
const SummaryInputSchema = z.object({
  text: z.string().describe('Text to summarize'),
  maxWords: z.number().optional().default(100),
});

const SummaryOutputSchema = z.object({
  summary: z.string(),
  keyPoints: z.array(z.string()),
});

export const summarizeFlow = ai.defineFlow(
  {
    name: 'summarizeFlow',
    inputSchema: SummaryInputSchema,
    outputSchema: SummaryOutputSchema,
  },
  async ({ text, maxWords }) => {
    const { output } = await ai.generate({
      model: googleAI.model('gemini-2.5-flash'),
      prompt: `Summarize the following text in at most ${maxWords} words and extract key points:\n\n${text}`,
      output: { schema: SummaryOutputSchema },
    });

    if (!output) throw new Error('No output generated');
    return output;
  }
);

// Call the flow
const result = await summarizeFlow({
  text: 'Long article content here...',
  maxWords: 50,
});
console.log(result.summary);

Generating Content

// Simple text generation
const { text } = await ai.generate({
  model: googleAI.model('gemini-2.5-flash'),
  prompt: 'Explain quantum computing in one sentence.',
});

// Structured output
const { output } = await ai.generate({
  prompt: 'List 3 programming languages with their use cases',
  output: {
    schema: z.object({
      languages: z.array(z.object({
        name: z.string(),
        useCase: z.string(),
      })),
    }),
  },
});

// With system prompt
const { text: response } = await ai.generate({
  system: 'You are a senior TypeScript engineer. Be concise.',
  prompt: 'What is the difference between interface and type in TypeScript?',
});

// Multimodal (image + text)
const { text: description } = await ai.generate({
  prompt: [
    { text: 'What is in this image?' },
    { media: { url: 'https://example.com/image.jpg', contentType: 'image/jpeg' } },
  ],
});

Streaming Flows

export const streamingFlow = ai.defineFlow(
  {
    name: 'streamingFlow',
    inputSchema: z.object({ topic: z.string() }),
    streamSchema: z.string(),        // type of each chunk
    outputSchema: z.object({ full: z.string() }),
  },
  async ({ topic }, { sendChunk }) => {
    const { stream, response } = ai.generateStream({
      prompt: `Write a detailed essay about ${topic}.`,
    });

    for await (const chunk of stream) {
      sendChunk(chunk.text);         // stream each token to client
    }

    const { text } = await response;
    return { full: text };
  }
);

// Client-side consumption
const stream = streamingFlow.stream({ topic: 'AI ethics' });
for await (const chunk of stream.stream) {
  process.stdout.write(chunk);
}
const finalOutput = await stream.output;

Tool Calling (Agents)

import { z } from 'genkit';

// Define tools
const getWeatherTool = ai.defineTool(
  {
    name: 'getWeather',
    description: 'Get current weather for a city',
    inputSchema: z.object({ city: z.string() }),
    outputSchema: z.object({ temp: z.number(), condition: z.string() }),
  },
  async ({ city }) => {
    // Call real weather API
    return { temp: 22, condition: 'sunny' };
  }
);

const searchWebTool = ai.defineTool(
  {
    name: 'searchWeb',
    description: 'Search the web for information',
    inputSchema: z.object({ query: z.string() }),
    outputSchema: z.string(),
  },
  async ({ query }) => {
    // Call search API
    return `Search results for: ${query}`;
  }
);

// Agent flow with tools
export const agentFlow = ai.defineFlow(
  {
    name: 'agentFlow',
    inputSchema: z.object({ question: z.string() }),
    outputSchema: z.string(),
  },
  async ({ question }) => {
    const { text } = await ai.generate({
      prompt: question,
      tools: [getWeatherTool, searchWebTool],
      returnToolRequests: false, // auto-execute tools
    });
    return text;
  }
);

Prompts with Dotprompt

Manage prompts as versioned .prompt files:

# src/prompts/summarize.prompt
---
model: googleai/gemini-2.5-flash
input:
  schema:
    text: string
    style?: string
output:
  schema:
    summary: string
    sentiment: string
---
Summarize the following text in a {{style, default: "professional"}} tone:

{{text}}

Return JSON with summary and sentiment (positive/negative/neutral).



// Load and use dotprompt
const summarizePrompt = ai.prompt('summarize');
const { output } = await summarizePrompt({
  text: 'Article content here...',
  style: 'casual',
});

RAG — Retrieval-Augmented Generation

import { devLocalVectorstore } from '@genkit-ai/dev-local-vectorstore';
import { textEmbedding004 } from '@genkit-ai/google-genai';

const ai = genkit({
  plugins: [
    googleAI(),
    devLocalVectorstore([{
      indexName: 'documents',
      embedder: textEmbedding004,
    }]),
  ],
});

// Index documents
await ai.index({
  indexer: devLocalVectorstoreIndexer('documents'),
  docs: [
    { content: [{ text: 'Document 1 content...' }], metadata: { source: 'doc1' } },
    { content: [{ text: 'Document 2 content...' }], metadata: { source: 'doc2' } },
  ],
});

// RAG flow
export const ragFlow = ai.defineFlow(
  {
    name: 'ragFlow',
    inputSchema: z.object({ question: z.string() }),
    outputSchema: z.string(),
  },
  async ({ question }) => {
    // Retrieve relevant documents
    const docs = await ai.retrieve({
      retriever: devLocalVectorstoreRetriever('documents'),
      query: question,
      options: { k: 3 },
    });

    // Generate answer grounded in retrieved docs
    const { text } = await ai.generate({
      system: 'Answer questions using only the provided context.',
      prompt: question,
      docs,
    });

    return text;
  }
);

Chat Sessions

export const chatFlow = ai.defineFlow(
  {
    name: 'chatFlow',
    inputSchema: z.object({ message: z.string(), sessionId: z.string() }),
    outputSchema: z.string(),
  },
  async ({ message, sessionId }) => {
    const session = ai.loadSession(sessionId) ?? ai.createSession({ sessionId });
    const chat = session.chat({
      system: 'You are a helpful assistant.',
    });

    const { text } = await chat.send(message);
    return text;
  }
);

Multi-Agent Systems

// Specialist agents
const researchAgent = ai.defineFlow(
  { name: 'researchAgent', inputSchema: z.string(), outputSchema: z.string() },
  async (query) => {
    const { text } = await ai.generate({
      system: 'You are a research expert. Gather facts and cite sources.',
      prompt: query,
      tools: [searchWebTool],
    });
    return text;
  }
);

const writerAgent = ai.defineFlow(
  { name: 'writerAgent', inputSchema: z.string(), outputSchema: z.string() },
  async (brief) => {
    const { text } = await ai.generate({
      system: 'You are a professional writer. Write clear, engaging content.',
      prompt: brief,
    });
    return text;
  }
);

// Orchestrator delegates to specialists
export const contentPipelineFlow = ai.defineFlow(
  {
    name: 'contentPipelineFlow',
    inputSchema: z.object({ topic: z.string() }),
    outputSchema: z.string(),
  },
  async ({ topic }) => {
    const research = await researchAgent(`Research: ${topic}`);
    const article = await writerAgent(`Write an article based on: ${research}`);
    return article;
  }
);

Developer Tools

CLI Commands

# Start Developer UI + connect to your app
genkit start -- npx tsx --watch src/index.ts
genkit start -o -- npx tsx src/index.ts    # auto-open browser

# Run a specific flow from CLI
genkit flow:run summarizeFlow '{"text": "Hello world", "maxWords": 10}'

# Run with streaming output
genkit flow:run streamingFlow '{"topic": "AI"}' -s

# Evaluate a flow
genkit eval:flow ragFlow --input eval-inputs.json

# View all commands
genkit --help

# Disable analytics telemetry
genkit config set analyticsOptOut true

Developer UI

The Developer UI runs at http://localhost:4000 and provides:

• Flow runner : Execute flows with custom JSON inputs

• Trace inspector : Visualize each step (generate, embed, retrieve, tool calls)

• Prompt playground : Test prompts interactively

• Model tester : Compare outputs across different models

• Evaluator : Run evaluation datasets against flows

  Add npm script for convenience

  package.json

  "scripts": { "genkit:dev": "genkit start -- npx tsx --watch src/index.ts" }

  npm run genkit:dev

Deployment

Firebase Cloud Functions

import { onCallGenkit } from 'firebase-functions/https';
import { defineSecret } from 'firebase-functions/params';

const apiKey = defineSecret('GOOGLE_AI_API_KEY');

export const summarize = onCallGenkit(
  { secrets: [apiKey] },
  summarizeFlow
);



firebase deploy --only functions

Express.js Server

import express from 'express';
import { expressHandler } from 'genkit/express';

const app = express();
app.use(express.json());

app.post('/summarize', expressHandler(summarizeFlow));
app.post('/chat', expressHandler(chatFlow));

app.listen(3000, () => console.log('Server running on port 3000'));

Cloud Run

# Build and deploy
gcloud run deploy genkit-app \
  --source . \
  --region us-central1 \
  --set-env-vars GEMINI_API_KEY=$GEMINI_API_KEY

Supported Plugins

Model Providers

Vector Databases

Best Practices

1. Always define input/output schemas — Use Zod objects for Dev UI labeled fields and API safety
2. Use flows for all AI logic — Even simple calls; flows give you tracing and deployment for free
3. Store API keys in environment variables — Never hardcode; use Firebase Secrets for production
4. Useai.run() to trace custom steps — Wrap non-Genkit code in ai.run() for trace visibility
5. Stream long-form content — Use defineFlow with streamSchema + sendChunk for better UX
6. Separate concerns with agents — Specialized subflows > one monolithic flow
7. Use Dotprompt for team prompts — .prompt files enable versioning, review, and reuse

Constraints

Must Do

• Define schemas for all flow inputs and outputs
• Handle null output from generate() — throw meaningful errors
• Set GENKIT_ENV=dev when running flows separately from the dev server
• Use onCallGenkit (not raw Cloud Functions) when deploying to Firebase

Must Not Do

• Never hardcode API keys in source code
• Do not use generate() outside a flow if you need tracing/observability
• Do not call genkit start without a command — always pass -- <your-run-command>
• Avoid blocking the event loop in tool handlers — use async/await

References

• Official Docs
• Get Started Guide
• Developer Tools
• Flows Reference
• Tool Calling
• RAG Guide
• Multi-Agent Systems
• Dotprompt
• GitHub Repository
• API References

Examples

Example 1: Minimal Flow

import { googleAI } from '@genkit-ai/google-genai';
import { genkit, z } from 'genkit';

const ai = genkit({ plugins: [googleAI()] });

export const helloFlow = ai.defineFlow(
  {
    name: 'helloFlow',
    inputSchema: z.object({ name: z.string() }),
    outputSchema: z.string(),
  },
  async ({ name }) => {
    const { text } = await ai.generate(`Say hello to ${name} in a creative way.`);
    return text;
  }
);

// Run it
const greeting = await helloFlow({ name: 'World' });
console.log(greeting);

Example 2: Full RAG + Agent Pipeline

import { googleAI, textEmbedding004 } from '@genkit-ai/google-genai';
import { devLocalVectorstore } from '@genkit-ai/dev-local-vectorstore';
import { genkit, z } from 'genkit';

const ai = genkit({
  plugins: [
    googleAI(),
    devLocalVectorstore([{ indexName: 'kb', embedder: textEmbedding004 }]),
  ],
});

// Index knowledge base documents
const indexKnowledgeBase = ai.defineFlow(
  { name: 'indexKB', inputSchema: z.array(z.string()) },
  async (texts) => {
    await ai.index({
      indexer: devLocalVectorstoreIndexer('kb'),
      docs: texts.map(text => ({ content: [{ text }] })),
    });
  }
);

// Answer questions using RAG
export const answerFlow = ai.defineFlow(
  {
    name: 'answerFlow',
    inputSchema: z.object({ question: z.string() }),
    outputSchema: z.object({ answer: z.string(), sources: z.number() }),
  },
  async ({ question }) => {
    const docs = await ai.retrieve({
      retriever: devLocalVectorstoreRetriever('kb'),
      query: question,
      options: { k: 5 },
    });

    const { text } = await ai.generate({
      system: 'Answer only from the provided context. If unsure, say so.',
      prompt: question,
      docs,
    });

    return { answer: text, sources: docs.length };
  }
);

Example 3: Multi-Model Comparison

import { googleAI } from '@genkit-ai/google-genai';
import { openAI } from 'genkitx-openai';
import { genkit, z } from 'genkit';

const ai = genkit({ plugins: [googleAI(), openAI()] });

export const compareModelsFlow = ai.defineFlow(
  {
    name: 'compareModelsFlow',
    inputSchema: z.object({ prompt: z.string() }),
    outputSchema: z.object({ gemini: z.string(), gpt4o: z.string() }),
  },
  async ({ prompt }) => {
    const [geminiResult, gptResult] = await Promise.all([
      ai.generate({ model: googleAI.model('gemini-2.5-flash'), prompt }),
      ai.generate({ model: 'openai/gpt-4o', prompt }),
    ]);

    return {
      gemini: geminiResult.text,
      gpt4o: gptResult.text,
    };
  }
);

Weekly Installs

1

Repository

akillness/oh-my-gods

First Seen

1 day ago

Security Audits

Gen Agent Trust HubPassSocketWarnSnykWarn

Installed on

mcpjam1

claude-code1

replit1

junie1

windsurf1

zencoder1