Init Genkit Project

Initialize a production-ready Firebase Genkit project with proper structure, configuration, and best practices.

Step 1: Determine Project Language

Ask the user to choose the target language:

• Node.js/TypeScript (Genkit 1.0 - Stable, recommended for most use cases)
• Python (Alpha - Early adopters, Python ecosystem integration)
• Go (1.0 - High performance, backend services)

Step 2: Initialize Project Structure

For Node.js/TypeScript

# Create project directory
mkdir my-genkit-app && cd my-genkit-app

# Initialize npm project
npm init -y

# Install Genkit dependencies
npm install genkit @genkit-ai/googleai @genkit-ai/firebase zod

# Install dev dependencies
npm install --save-dev typescript @types/node

# Initialize TypeScript
npx tsc --init

Create tsconfig.json:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "lib": ["ES2020"],
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "moduleResolution": "node",
    "resolveJsonModule": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

Create src/index.ts:

import { genkit, z } from 'genkit';
import { googleAI, gemini25Flash } from '@genkit-ai/googleai';
import { firebase } from '@genkit-ai/firebase';

const ai = genkit({
  plugins: [
    googleAI({
      apiKey: process.env.GOOGLE_API_KEY,
    }),
    firebase({
      projectId: process.env.GOOGLE_CLOUD_PROJECT,
    }),
  ],
  model: gemini25Flash,
  enableTracingAndMetrics: true,
});

// Example flow
…

Create package.json scripts:

{
  "scripts": {
    "dev": "genkit start -- tsx --watch src/index.ts",
    "build": "tsc",
    "deploy": "firebase deploy --only functions",
    "genkit:dev": "genkit start"
  }
}

For Python

# Create project directory
mkdir my-genkit-app && cd my-genkit-app

# Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install Genkit
pip install genkit google-generativeai

# Create requirements.txt
pip freeze > requirements.txt

Create main.py:

from genkit import genkit
from genkit.plugins import google_ai

ai = genkit(
    plugins=[
        google_ai.google_ai(api_key=os.environ.get("GOOGLE_API_KEY"))
    ],
    model="gemini-2.5-flash"
)

@ai.flow
async def example_flow(query: str) -> str:
    """Example Genkit flow."""
    response = await ai.generate(
        model="gemini-2.5-flash",
        prompt=f"You are a helpful assistant. Respond to: {query}"
    )
    return response.text
…

For Go

# Create project directory
mkdir my-genkit-app && cd my-genkit-app

# Initialize Go module
go mod init my-genkit-app

# Install Genkit
go get github.com/firebase/genkit/go/genkit
go get github.com/firebase/genkit/go/plugins/googleai

Create main.go:

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/firebase/genkit/go/genkit"
    "github.com/firebase/genkit/go/plugins/googleai"
)

func main() {
    ctx := context.Background()

    // Initialize Genkit with Google AI
    if err := genkit.Init(ctx, &genkit.Config{
        Plugins: []genkit.Plugin{
…

Step 3: Environment Configuration

Create .env file:

# Google API Key (for Google AI plugin)
GOOGLE_API_KEY=your_api_key_here

# Google Cloud Project (for Firebase/Vertex AI)
GOOGLE_CLOUD_PROJECT=your-project-id

# Environment
NODE_ENV=development

Create .env.example (committed to git):

GOOGLE_API_KEY=
GOOGLE_CLOUD_PROJECT=
NODE_ENV=development

Step 4: Project Structure

Create recommended directory structure:

my-genkit-app/
├── src/                    # Source code
│   ├── flows/             # Flow definitions
│   ├── tools/             # Tool definitions
│   ├── retrievers/        # RAG retrievers
│   └── index.ts           # Main entry point
├── tests/                 # Test files
├── .env                   # Environment variables (gitignored)
├── .env.example           # Example env file (committed)
├── .gitignore             # Git ignore
├── tsconfig.json          # TypeScript config (for TS)
├── package.json           # Dependencies (for Node.js)
├── requirements.txt       # Dependencies (for Python)
├── go.mod                 # Dependencies (for Go)
└── README.md              # Project documentation

Step 5: Configure Monitoring (Production)

For Firebase deployment with AI monitoring:

# Install Firebase CLI
npm install -g firebase-tools

# Login to Firebase
firebase login

# Initialize Firebase
firebase init

# Select:
# - Functions
# - Enable AI monitoring (when prompted)

Update firebase.json:

{
  "functions": [
    {
      "source": ".",
      "codebase": "default",
      "runtime": "nodejs20",
      "ai": {
        "monitoring": {
          "enabled": true
        }
      }
    }
  ]
}