Genkit

https://genkit.dev
Admin
Genkit is an open-source framework by Google for building full-stack AI-powered applications. It...
Tokens:1,096,377
Snippets:8,003
Trust Score:7.6
Update:1 week ago
Show doc for...
Tokens:
Raw
### Start Genkit Developer UI with Go examples

Source: https://genkit.dev/docs/devtools

Examples of starting the Developer UI for Go applications, either the main package or a specific file.

```bash
# Running a Go application
genkit start -- go run .

# Running a specific Go file
genkit start -- go run main.go
```

--------------------------------

### Start Genkit Developer UI with Dart examples

Source: https://genkit.dev/docs/devtools

Examples of starting the Developer UI for Dart applications, either the default entrypoint or a specific file.

```bash
# Running a Dart application
genkit start -- dart run

# Running a specific Dart file
genkit start -- dart run bin/my_app.dart
```

--------------------------------

### Start Genkit Developer UI with Python examples

Source: https://genkit.dev/docs/devtools

Examples of starting the Developer UI for Python applications, including running a main script, a specific file, or with a virtual environment activated.

```bash
# Running a Python application
genkit start -- python3 main.py

# Running a specific Python file
genkit start -- python3 src/app.py

# Running with a virtual environment activated
genkit start -- python main.py
```

--------------------------------

### Get started with Genkit using Gemini, Imagen, OpenAI, or Ollama

Source: https://genkit.dev/docs/python/overview

Shows how to initialize Genkit with a provider plugin and generate a response. Each tab uses a different provider: GoogleAI (Gemini and Imagen), OpenAI, and Ollama. The Gemini and OpenAI examples print the response text; the Imagen example prints the media URL if media exists; the Ollama example defines a local model with ModelDefinition.

```python
from genkit import Genkit
from genkit_google_genai import GoogleAI

ai = Genkit(
plugins=[GoogleAI()],
)

response = await ai.generate(
model='googleai/gemini-flash-latest',
prompt='Why is the sky blue?'
)
print(response.text)
```

```python
from genkit import Genkit
from genkit_google_genai import GoogleAI

ai = Genkit(
    plugins=[GoogleAI()],
)

response = await ai.generate(
    model='googleai/imagen-3.0-generate-002',
    prompt='a banana riding a bicycle',
)
if response.media:
    print(response.media[0].url)
```

```python
from genkit import Genkit
from genkit_openai import OpenAI

ai = Genkit(
plugins=[OpenAI()],
)

response = await ai.generate(
model='openai/gpt-5.5',
prompt='Why is the sky blue?'
)
print(response.text)
```

```python
from genkit import Genkit
from genkit_ollama import Ollama, ModelDefinition

ai = Genkit(
	plugins=[
		Ollama(
			models=[
				ModelDefinition(name='gemma4:latest'),
			],
		)
	],
)

response = await ai.generate(
	model="ollama/gemma4:latest",
	prompt='Why is the sky blue?'
)
print(response.text)
```

--------------------------------

### Developer UI startup output

Source: https://genkit.dev/docs/js/devtools

Example output after running the start command, showing the Telemetry API and Developer UI addresses.

```bash
Telemetry API running on http://localhost:4033
Genkit Developer UI: http://localhost:4000
```

--------------------------------

### Start Developer UI with common run commands

Source: https://genkit.dev/docs/js/devtools

Examples of starting the Developer UI with typical development servers, including watch mode for auto-reload.

```bash
# Running a typical development server
genkit start -- npm run dev

# Running a TypeScript file directly
genkit start -- npx tsx --watch src/index.ts

# Running a JavaScript file directly
genkit start -- node --watch src/index.js
```

--------------------------------

### Start Genkit Developer UI with JavaScript examples

Source: https://genkit.dev/docs/devtools

Examples of starting the Developer UI for JavaScript projects, including typical development server, TypeScript, and JavaScript files. The --watch option enables hot reload.

```bash
# Running a typical development server
genkit start -- npm run dev

# Running a TypeScript file directly
genkit start -- npx tsx --watch src/index.ts

# Running a JavaScript file directly
genkit start -- node --watch src/index.js
```

--------------------------------

### Genkit Developer UI startup output

Source: https://genkit.dev/docs/dart/devtools

Example output after running the start command, showing the telemetry API and Developer UI addresses.

```bash
Telemetry API running on http://localhost:4033
Genkit Developer UI: http://localhost:4000
```

--------------------------------

### Go application setup for developer UI

Source: https://genkit.dev/docs/go/dotprompt

Starts a Genkit application with the Google AI plugin and blocks execution to use the developer UI. This is the starting point for creating prompt files via the UI.

```go
package main

import (
	"context"

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

func main() {
	genkit.Init(context.Background(), genkit.WithPlugins(&googlegenai.GoogleAI{}))

	// Blocks end of program execution to use the developer UI.
	select {}
}
```

--------------------------------

### Go: Define a tool and start an MCP server over stdio

Source: https://genkit.dev/docs/go/model-context-protocol

This example shows how to create a Genkit instance, define a tool named 'add' that adds two numbers, and start an MCP server over stdio. The server automatically discovers all tools defined on the Genkit instance, so the tool does not need to be listed explicitly. Note that in stdio mode, the server owns stdout; use the standard log package (which writes to stderr) for diagnostics, and avoid writing to stdout.

```go
package main

import (
	"context"
	"log"

	"github.com/firebase/genkit/go/ai"
	"github.com/firebase/genkit/go/genkit"
	"github.com/firebase/genkit/go/plugins/mcp"
)

type addInput struct {
	A int `json:"a"`
	B int `json:"b"`
}

func main() {
	ctx := context.Background()
	g := genkit.Init(ctx)

	// NewMCPServer picks up every tool already defined on g, so this value
	// does not need to be referenced again.
	genkit.DefineTool(g, "add", "Add two numbers",
		func(ctx *ai.ToolContext, in addInput) (int, error) {
			return in.A + in.B, nil
		})

	srv := mcp.NewMCPServer(g, mcp.MCPServerOptions{
		Name:    "genkit-calculator",
		Version: "1.0.0",
	})

	log.Println("starting MCP server on stdio")
	if err := srv.ServeStdio(); err != nil {
		log.Fatal(err)
	}
}
```

--------------------------------

### Install @toolbox-sdk/core

Source: https://genkit.dev/docs/integrations/toolbox

Install the @toolbox-sdk/core package, which Genkit requires to use Toolbox. Run this command before getting started.

```bash
npm install @toolbox-sdk/core
```

--------------------------------

### Create Go module for bargain-chef

Source: https://genkit.dev/docs/backend-frameworks/echo

Initializes a new Go module named example/bargain-chef in a new directory.

```bash
mkdir bargain-chef && cd bargain-chef
go mod init example/bargain-chef
```

--------------------------------

### Create Go project and initialize module

Source: https://genkit.dev/docs/backend-frameworks/gin

Run these commands to create a new directory and initialize a Go module for the Gin tutorial.

```bash
mkdir my-genkit-gin && cd my-genkit-gin
go mod init example/my-genkit-gin
```

--------------------------------

### Create Go project

Source: https://genkit.dev/docs/backend-frameworks/nethttp

Creates a new directory for the project and initializes a Go module named example/my-genkit-nethttp.

```bash
mkdir my-genkit-nethttp && cd my-genkit-nethttp
go mod init example/my-genkit-nethttp
```

--------------------------------

### Build and start the server locally

Source: https://genkit.dev/docs/deployment/any-platform

Runs the build command and then starts the server to test locally.

```bash
npm run build

npm start
```

--------------------------------

### Start Genkit application

Source: https://genkit.dev/docs/evaluation

Starts the Genkit application with the Go main file. Used to run the application after setup.

```bash
genkit start -- go run main.go
```

--------------------------------

### Install the Google Cloud plugin with go get

Source: https://genkit.dev/docs/integrations/google-cloud

Installs the Genkit Google Cloud plugin for Go. Requires the Google Cloud CLI tool to be installed locally.

```bash
go get github.com/firebase/genkit/go/plugins/googlecloud
```

--------------------------------

### Create project directory and navigate

Source: https://genkit.dev/docs/go/deployment/any-platform

Creates a directory for the Genkit sample project and changes into it. Use this as the first step in setting up your deployment environment.

```bash
mkdir -p ~/tmp/genkit-cloud-project

cd ~/tmp/genkit-cloud-project
```

--------------------------------

### get_usage_guide

Source: https://genkit.dev/docs/mcp-server

Fetches a usage guide for the Genkit AI framework. Specify the language (js or go) to get the guide for that SDK.

```APIDOC
## get_usage_guide

### Description
Fetches a usage guide for the Genkit AI framework. The guide includes best practices and recommended project structure and plugins. Intended for AI assistants to understand building Genkit apps.

### Method
MCP Tool

### Endpoint
@genkit:get_usage_guide

### Parameters
#### Request Body
- **language** (string) - Required - The language for the guide. Accepts `js` or `go`. Defaults to `js` if omitted.

### Request Example
@genkit:get_usage_guide { "language": "js" }

### Response
Returns the usage guide content for the specified language.
```

--------------------------------

### Starting the server with plugins/server Start helper

Source: https://genkit.dev/docs/concurrency

Uses the `server.Start` helper from `plugins/server` to handle the Cloud Run lifecycle: it listens, traps SIGINT and SIGTERM, and drains in-flight requests for up to five seconds before returning. Blocks until interrupted.

```go
import "github.com/firebase/genkit/go/plugins/server"

mux := http.NewServeMux()
mux.HandleFunc("POST /myFlow", genkit.Handler(myFlow))

// Blocks until interrupted, then drains.
log.Fatal(server.Start(ctx, "0.0.0.0:"+os.Getenv("PORT"), mux))
```

--------------------------------

### Create project directory

Source: https://genkit.dev/docs/deployment/any-platform

Sets up the project home directory and creates the src folder.

```bash
export GENKIT_PROJECT_HOME=~/tmp/genkit-express-project

mkdir -p $GENKIT_PROJECT_HOME
cd $GENKIT_PROJECT_HOME
mkdir src
```

--------------------------------

### Install the AWS Bedrock Go plugin with go get

Source: https://genkit.dev/docs/go/integrations/aws-bedrock

Use this command to install the plugin package. It is the first step before using the plugin in your Go project.

```bash
go get github.com/xavidop/genkit-aws-bedrock-go
```

--------------------------------

### Go: Basic xAI plugin setup

Source: https://genkit.dev/docs/integrations/xai

Initializes Genkit with the xAI plugin and sets a default model. Requires the XAI_API_KEY environment variable; otherwise genkit.Init panics.

```go
package main

import (
	"context"

	"github.com/firebase/genkit/go/genkit"
	"github.com/firebase/genkit/go/plugins/compat_oai/xai"
)

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

	g := genkit.Init(ctx,
		genkit.WithPlugins(&xai.XAI{}),
		genkit.WithDefaultModel("xai/grok-4.6"),
	)
}
```

--------------------------------

### Get Genkit usage guide for JS and Go

Source: https://genkit.dev/docs/mcp-server

Use the get_usage_guide tool to fetch a usage guide for the Genkit AI framework. Specify the language explicitly; it defaults to 'js' if omitted. The guide includes best practices, project structure, and plugins.

```text
@genkit:get_usage_guide { "language": "js" }
@genkit:get_usage_guide { "language": "go" }
```

--------------------------------

### Configure Ollama embedders and get embeddings

Source: https://genkit.dev/docs/integrations/ollama

Configure the Ollama plugin with an embedder named 'nomic-embed-text' with 384 dimensions, then use ai.embed to get embeddings for a text. The example logs the resulting embedding vector.

```typescript
const ai = genkit({
  plugins: [
    ollama({
      serverAddress: 'http://localhost:11434',
      embedders: [{ name: 'nomic-embed-text', dimensions: 768 }],
    }),
  ],
});

async function getEmbeddings() {
  const embeddings = (
    await ai.embed({
      embedder: 'ollama/nomic-embed-text',
      content: 'Some text to embed!',
    })
  )[0].embedding;

  return embeddings;
}

getEmbeddings().then((e) => console.log(e));
```

--------------------------------

### Install textsplitter and pdf dependencies

Source: https://genkit.dev/docs/rag

Install the `textsplitter` library from `langchaingo` and the `ledongthuc/pdf` PDF parsing library using `go get`. These are not Genkit dependencies; any Go text splitter and PDF reader can be used.

```bash
go get github.com/tmc/langchaingo/textsplitter
go get github.com/ledongthuc/pdf
```

--------------------------------

### Set up project with uv

Source: https://genkit.dev/docs/deployment/any-platform

Initializes a new Python project with uv and adds the required dependencies: genkit, genkit-google-genai, fastapi, and uvicorn.

```bash
mkdir -p ~/tmp/genkit-plain-fastapi
cd ~/tmp/genkit-plain-fastapi

uv init
uv add genkit genkit-google-genai fastapi uvicorn
```

--------------------------------

### Create Go project and initialize module

Source: https://genkit.dev/docs/backend-frameworks/chi

Run these commands to create a new directory and initialize a Go module for the Chi Genkit backend.

```bash
mkdir my-genkit-chi && cd my-genkit-chi
go mod init example/my-genkit-chi
```

--------------------------------

### Install Genkit CLI and start Developer UI

Source: https://genkit.dev/docs/get-started

Installs the Genkit CLI and runs the program under it to open the Developer UI at http://localhost:4000. Provides a visual flow runner and trace for every model call.

```bash
curl -sL cli.genkit.dev | bash
genkit start -- go run .
```

--------------------------------

### Python: Genkit setup for developer UI

Source: https://genkit.dev/docs/dotprompt

Python code that creates a Genkit instance with the Google AI plugin. This is the minimal setup for using the developer UI. The command starts the developer UI with the Python script.

```python
from genkit import Genkit
from genkit_google_genai import GoogleAI

ai = Genkit(
    plugins=[GoogleAI()],
)
```

```bash
genkit start -- uv run src/main.py
```

--------------------------------

### Install Go packages for Genkit, Chi, and GenAI

Source: https://genkit.dev/docs/backend-frameworks/chi

Run these go get commands to install the required Go packages: Genkit core, Google GenAI plugin, Chi router, CORS middleware, and Google's GenAI SDK.

```bash
go get github.com/firebase/genkit/go
go get github.com/firebase/genkit/go/plugins/googlegenai
go get github.com/go-chi/chi/v5
go get github.com/go-chi/cors
go get google.golang.org/genai
```

--------------------------------

### Create project and install dependencies

Source: https://genkit.dev/docs/backend-frameworks/django

Initializes a new Django project with uv, installs required packages (django, django-cors-headers, uvicorn, genkit, genkit-django, genkit-google-genai), and creates the 'recipes' app.

```bash
mkdir my-genkit-django
cd my-genkit-django
uv init --no-readme --python 3.11
uv add django django-cors-headers uvicorn genkit genkit-django genkit-google-genai
uv run django-admin startproject myproject .
uv run python manage.py startapp recipes
```

--------------------------------

### Install the A2UI Go package

Source: https://genkit.dev/docs/agents/a2ui

Adds the A2UI plugin to a Go module. The package declares itself `exp`, so examples import it as `a2uix`.

```bash
go get github.com/firebase/genkit/go/plugins/a2ui/exp
```

--------------------------------

### Start the Chi server

Source: https://genkit.dev/docs/backend-frameworks/chi

Run the server from the project root. The server listens on http://localhost:8080 and exposes POST /bargainChefFlow.

```bash
go run .
```

--------------------------------

### main.go: Full Genkit backend with Chi server

Source: https://genkit.dev/docs/backend-frameworks/chi

This is the complete main.go file for the backend. It initializes Genkit with the Google AI plugin, defines the getIngredientsOnSale tool, defines the bargainChefFlow streaming flow, and sets up a Chi router with CORS and a POST endpoint. The flow prompts Gemini to generate a recipe, calls the tool, and streams partial recipe chunks back to the caller.

```go
package main

import (
	"context"
	"errors"
	"log"
	"net/http"
	"time"

	"github.com/firebase/genkit/go/ai"
	"github.com/firebase/genkit/go/genkit"
	"github.com/firebase/genkit/go/plugins/googlegenai"
	"github.com/go-chi/chi/v5"
	chimw "github.com/go-chi/chi/v5/middleware"
	"github.com/go-chi/cors"
	"google.golang.org/genai"
)

type DayType string

const (
	DayTypeWeekday DayType = "weekday"
	DayTypeWeekend DayType = "weekend"
)

type SaleQuery struct {
	DayType DayType `json:"dayType" jsonschema:"enum=weekday,enum=weekend,description=Whether to fetch weekday or weekend sale prices."`
}

type SaleIngredient struct {
	Name  string `json:"name"`
	Price string `json:"price"`
}

type RecipeIngredient struct {
	Name     string `json:"name"`
	Quantity string `json:"quantity"`
	OnSale   bool   `json:"onSale"`
}

type Recipe struct {
	Title       string             `json:"title"`
	Description string             `json:"description"`
	Servings    int                `json:"servings"`
	Ingredients []RecipeIngredient `json:"ingredients"`
	Steps       []string           `json:"steps"`
}

type CravingInput struct {
	Craving string `json:"craving" jsonschema_description:"What the user feels like eating right now."`
}

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

	g := genkit.Init(ctx,
		genkit.WithPlugins(&googlegenai.GoogleAI{}),
	)

	getIngredientsOnSale := genkit.DefineTool(g, "getIngredientsOnSale",
		"Returns the ingredients on sale at the local grocery store, with prices. The sale set differs between weekdays and weekends.",
		func(toolCtx *ai.ToolContext, input SaleQuery) ([]SaleIngredient, error) {
			// Mock data: in a real app, query a pricing database.
			if input.DayType == DayTypeWeekend {
				return []SaleIngredient{
					{Name: "chicken breast", Price: "$2.99/lb"},
					{Name: "pasta", Price: "$0.79"},
					{Name: "canned tomatoes", Price: "$0.99"},
					{Name: "garlic", Price: "$0.50 / head"},
					{Name: "olive oil", Price: "$6.99"},
				}, nil
			}
			return []SaleIngredient{
				{Name: "eggs", Price: "$3.49 / dozen"},
				{Name: "spinach", Price: "$1.99"},
				{Name: "parmesan", Price: "$4.99"},
				{Name: "lemons", Price: "$0.50 each"},
				{Name: "rice", Price: "$2.49"},
				{Name: "butter", Price: "$3.99"},
			}, nil
		},
	)

	bargainChefFlow := genkit.DefineStreamingFlow(g, "bargainChefFlow",
		func(ctx context.Context, input CravingInput, sendChunk func(context.Context, Recipe) error) (Recipe, error) {
			today := time.Now().Weekday().String()

			prompt := "Today is " + today + ". The user is craving: " + input.Craving + ".\n\n" +
				"Call the getIngredientsOnSale tool with the dayType that matches today. Saturday and Sunday are weekends; all other days are weekdays. " +
				"Then propose ONE recipe that takes advantage of those deals. For each ingredient, set onSale=true if it appears in the tool's response, false otherwise."

			for value, err := range genkit.GenerateDataStream[Recipe](ctx, g,
				ai.WithModelName("googleai/gemini-flash-latest"),
				ai.WithConfig(&genai.GenerateContentConfig{
					ThinkingConfig: &genai.ThinkingConfig{
						ThinkingLevel: genai.ThinkingLevelMinimal,
					},
				}),
				ai.WithPrompt(prompt),
				ai.WithTools(getIngredientsOnSale),
			) {
				if err != nil {
					return Recipe{}, err
				}
				if value.Done {
					return value.Output, nil
				}
				if err := sendChunk(ctx, value.Chunk); err != nil {
					return Recipe{}, err
				}
			}

			return Recipe{}, errors.New("the stream ended without a final recipe")
		},
	)

	r := chi.NewRouter()
	r.Use(chimw.Logger)
	r.Use(cors.Handler(cors.Options{
		AllowedOrigins: []string{"*"},
		AllowedMethods: []string{"POST", "OPTIONS"},
		AllowedHeaders: []string{"Content-Type", "Accept"},
	}))
	r.Post("/bargainChefFlow", genkit.Handler(bargainChefFlow))

	log.Println("Chi server listening on http://localhost:8080")
	if err := http.ListenAndServe(":8080", r); err != nil {
		log.Fatalf("server error: %v", err)
	}
}

```

--------------------------------

### Get started with OpenAI using compat_oai plugin

Source: https://genkit.dev/docs/go/overview

Complete Go program that initializes Genkit with the OpenAI plugin and generates a text response using the 'openai/gpt-5.5' model. Requires 'OPENAI_API_KEY' in the environment and running 'go get github.com/firebase/genkit/go' then 'go mod tidy'.

```go
package main

import (
	"context"
	"log"

	"github.com/firebase/genkit/go/ai"
	"github.com/firebase/genkit/go/genkit"
	"github.com/firebase/genkit/go/plugins/compat_oai/openai"
)

func main() {
	ctx := context.Background()
	g := genkit.Init(ctx, genkit.WithPlugins(&openai.OpenAI{}))

	resp, err := genkit.Generate(ctx, g,
		ai.WithPrompt("Why is the sky blue?"),
		ai.WithModelName("openai/gpt-5.5"),
	)
	if err != nil {
		log.Fatal(err)
	}

	log.Println(resp.Text())
}
```

--------------------------------

### Initialize Firebase Hosting

Source: https://genkit.dev/docs/deployment/firebase

Sets up Firebase Hosting in the project directory. Accept the defaults for all prompts.

```bash
cd $PROJECT_ROOT

firebase init hosting
```

--------------------------------

### Create the FastAPI project

Source: https://genkit.dev/docs/backend-frameworks/fastapi

Initializes a new Python project named bargain-chef using uv, sets the Python version to 3.10, and changes into the project directory.

```bash
mkdir bargain-chef
cd bargain-chef
uv init --no-readme --python 3.10
```
Tokens:
Raw