AutoGineer
Generated banner for Developing Genkit Python
Generated logo for Developing Genkit Python

Developing Genkit Python

GoogleOfficialPublished by Google

  • Skill
  • Tool integration
  • Data and AI
  • Apache-2.0
  • Medium risk
Download ZIP

From the author

Develop AI-powered applications using Genkit in Python. Use when the user asks about Genkit, AI agents, flows, or tools in Python, or when encountering Genkit errors, import issues, or API problems.
— the description by Google

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The Genkit Python SDK provides a unified framework for developing AI features, including generation, streaming, tool integration, and multi-turn agents. It emphasizes a developer-centric workflow that integrates with the Genkit CLI for tracing, debugging, and monitoring model interactions. The framework supports advanced agent capabilities such as session management, human-in-the-loop interactions, branching, and background task execution.

What it does

  • Provides a unified SDK for building AI agents, flows, and generative features in Python.
  • Supports multi-turn agent interactions with state management and session persistence.
  • Enables observability through the Genkit CLI for tracing model inputs, outputs, and tool calls.
  • Facilitates integration with FastAPI for serving agents and flows.
  • Supports advanced agent patterns like background task execution, branching, and human-in-the-loop approval.
  • Includes tools for evaluating AI performance and managing prompts.

When to use it

  • When building AI-powered applications or chatbots in Python.
  • When you need to implement multi-turn agents with history and state.
  • When you need to debug AI model interactions, tool calls, or latency issues.
  • When you require a structured way to define and run generative flows.
  • When you need to integrate human-in-the-loop or background processing into AI workflows.

Advantages

  • Unified SDK for diverse AI tasks including generation, agents, and flows.
  • Powerful CLI-based tracing and debugging that works without modifying application code.
  • Native support for complex agent patterns like branching and background work.
  • Flexible session management for persistent agent interactions.
  • Seamless integration with existing Python web frameworks like FastAPI.

Usage examples

“How do I generate a simple response using Genkit in Python?”
The agent provides a code snippet using the Genkit class and GoogleAI plugin to perform a basic generate call.
“How can I debug my Genkit application to see tool calls?”
The agent explains how to use 'genkit start -- uv run src/main.py' to capture traces and inspect them via the Dev UI or CLI.
“How do I run a specific flow from the command line?”
The agent provides the 'genkit flow:run' command syntax to execute a named flow with specific input data.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/google/developing-genkit-python/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip developing-genkit-python.zip -d .agents/skills

Documentation by Google

Genkit Python

Build AI features in Python — generate, stream, tools, flows, and multi-turn agents — with one SDK.

Prerequisites

  • Python 3.10+ and uv (install)

  • Genkit CLI: npm install -g genkit-cli if genkit --version is missing

New app? Setup. Patterns? Examples.

Hello World

from genkit import Genkit
from genkit_google_genai import GoogleAI

ai = Genkit(
    plugins=[GoogleAI()],
    model='googleai/gemini-flash-latest',
)

async def main():
    response = await ai.generate(prompt='Tell me a joke about Python.')
    print(response.text)

if __name__ == '__main__':
    ai.run_main(main())

Agents (Beta)

Multi-turn chats with history, typed state, human approval, branching, and background work. Start here: Agents.

chat = agent.chat()
res = await chat.send('Hello')           # AgentResponse
turn = chat.send_stream('Hello')         # AgentTurn — .stream / .response

More: sessions · HITL · branching · background · state · artifacts · custom · HTTP

Imports

  • Google AI: from genkit_google_genai import GoogleAI

  • Agents: from genkit.agent import InMemorySessionStore, ...

  • Middleware: from genkit_middleware import Middleware, ToolApproval, ...

  • FastAPI: from genkit_fastapi import serve_agent, serve_flow

  • Evals: from genkit_evaluators import register_genkit_evaluators

Workflow

  1. Agent or flow? If the task is conversational, multi-turn, or described as "an agent", "assistant", or "chatbot", build it with ai.define_agent (see Agents) rather than hand-rolling a generate + tools loop inside a flow. Reach for a plain flow only for single-shot, stateless generation.

  2. Set GEMINI_API_KEY. Use prefixed model ids (googleai/gemini-flash-latest).

  3. Enter via ai.run_main(main()) for Genkit apps (especially under genkit start). See Common Errors.

  4. Run with Dev Workflow (genkit start + Dev UI).

  5. Verify with traces, not a blind run. Running the app directly (uv run) does not capture dev traces. See Genkit CLI for how to run your app and capture traces.

  6. Stuck? Common Errors first.

Genkit CLI (recommended)

genkit start unintrusively wraps any Python program that uses the Genkit library, running it unchanged while capturing traces from every Genkit action so you can prove tools were actually called and inspect model I/O from the terminal, even for headless checks. It forwards stdio, so interactive CLI tools that rely on stdin/stdout work without issues. Running the app directly (uv run) skips trace capture, so you're debugging blind.

Primary pattern (default): prefix genkit start -- to your normal run command. This collects telemetry from any Genkit code your program runs, whether triggered from the dev UI, your own web server/web UI, or a plain script:

genkit start -- uv run src/main.py
genkit start --noui -- uv run src/main.py   # same, without the Dev UI (still a persistent server)

genkit start runs until you stop it with Ctrl+C. That is expected and correct for the common cases: a server your web/mobile app calls, or an interactive CLI you exit yourself. --noui only drops the Dev UI; it is not a one-shot command and will not exit on its own. Do not use genkit start as a blocking step in automated/non-interactive contexts; use flow:run (below) for that.

Non-interactive use (agents/CI): add the global --non-interactive flag before -- so the CLI uses defaults and never blocks on a prompt (e.g. the first-run analytics notice): genkit start --non-interactive -- uv run src/main.py (works with flow:run too).

Run a flow (flow:run): invoke a specific flow by name from the CLI. Append your run command after -- to spin up the runtime just for this run (the command runs as-is to register your flows):

genkit flow:run myFlow '{"data": "input"}' -- uv run src/main.py

This is self-terminating: it runs the flow once, prints a Trace ID, then exits, so it's the right choice for a quick, non-interactive check (unlike genkit start). Note: flow:run runs flows (@ai.flow()), not agents; you can't flow:run an agent (ai.define_agent) directly. To exercise an agent from the CLI, wrap one turn in a throwaway flow and run that (see Agents).

Debugging with traces: the fastest way to see prompts, model inputs/outputs, tool calls, latencies, and errors. Inspect from the terminal after any run under genkit start:

genkit trace:list                        # find recent trace IDs
genkit trace:get <traceId>               # full trace details (inputs, outputs, tool calls, errors)
genkit trace:get <traceId> --format json # machine-readable JSON, safe to pipe into jq or other parsers

For machine-readable output, pass --format json to get clean JSON you can pipe into jq or other parsers. The default output is human-oriented (banner/log lines, possible truncation on large traces), so don't pipe that form directly; use --format json, grep, or the Dev UI trace viewer.

See Dev Workflow for the full checklist and Dev UI walkthrough.

References

Files

references/examples.md

Genkit Python Examples

Minimal patterns for common Genkit APIs. Examples use Google AI (GoogleAI, googleai/...); other providers use the same patterns with the right plugin and model prefix.

Public imports

Use public packages only — genkit, genkit_google_genai, genkit_fastapi, genkit_middleware, genkit_evaluators, genkit.agent, genkit.embedder, genkit.evaluator, genkit.model, etc. Do not import internal modules (genkit._core, …).

from genkit import Genkit, ActionRunContext
from genkit_google_genai import GoogleAI

ai = Genkit(plugins=[GoogleAI()], model='googleai/gemini-flash-latest')

For agents, see Agents (from genkit.agent import ...).

Structured output

from pydantic import BaseModel, TypeAdapter

class CityInfo(BaseModel):
    name: str
    population: int
    country: str

response = await ai.generate(
    prompt='Give facts about Tokyo.',
    output_format='json',
    output_schema=CityInfo,
)
city = response.output

# Arrays
schema = TypeAdapter(list[CityInfo]).json_schema()
response = await ai.generate(
    prompt='List 3 cities.',
    output_format='array',
    output_schema=schema,
)

Output formats: 'text', 'json', 'array', 'enum', 'jsonl'.

Streaming (text)

sr = ai.generate_stream(prompt='Tell me a story.')
async for chunk in sr.stream:
    if chunk.text:
        print(chunk.text, end='', flush=True)
final = await sr.response  # final.text

You do not need to drain .stream for the turn to finish — await sr.response completes even if you break out of the loop early (same idea as agent send_stream).

Text and media parts

# Non-streaming
response = await ai.generate(prompt='...')
for media in response.media:
    print(media.content_type, (media.url or '')[:80])

# Streaming — media usually complete on the final response
from genkit import MediaPart

sr = ai.generate_stream(prompt='...')
async for chunk in sr.stream:
    if chunk.text:
        print(chunk.text, end='', flush=True)
final = await sr.response
for media in final.media:
    print(media.content_type, (media.url or '')[:80])

if final.message:
    for part in final.message.content:
        if isinstance(part.root, MediaPart) and part.root.media:
            print(part.root.media.content_type)

Sending image / media input

The section above covers model-produced media. To send an image to Gemini, build a user Message with text + MediaPart (URL or data URI):

from genkit import Media, MediaPart, Message, Part, Role, TextPart

image_url = 'https://example.com/cat.jpg'  # or data:image/png;base64,...
msg = Message(
    role=Role.USER,
    content=[
        Part(root=TextPart(text='What is in this image?')),
        Part(root=MediaPart(media=Media(url=image_url, content_type='image/jpeg'))),
    ],
)
response = await ai.generate(messages=[msg])
print(response.text)

Prefer a vision-capable model (googleai/gemini-flash-latest). URLs are fetched server-side — hotlink-blocked or thumbnail URLs often fail. Prefer a direct image URL or a data URI:

import base64
b64 = base64.b64encode(Path('cat.png').read_bytes()).decode()
url = f'data:image/png;base64,{b64}'

Streaming + structured output

class StoryAnalysis(BaseModel):
    title: str
    genre: str
    summary: str

sr = ai.generate_stream(
    prompt='Write a short story then analyze it.',
    output_format='json',
    output_schema=StoryAnalysis,
)
async for chunk in sr.stream:
    if chunk.text:
        print(chunk.text, end='', flush=True)
final = await sr.response
analysis = final.output

Flows

class SummarizeInput(BaseModel):
    text: str

@ai.flow()
async def summarize(input: SummarizeInput) -> str:
    response = await ai.generate(prompt=f'Summarize: {input.text}')
    return response.text

Streaming flows

@ai.flow()
async def stream_story(subject: str, ctx: ActionRunContext) -> str:
    sr = ai.generate_stream(prompt=f'Story about {subject}.')
    full = ''
    async for chunk in sr.stream:
        if chunk.text:
            ctx.send_chunk(chunk.text)
            full += chunk.text
    return full

Tools

Parameters must be a Pydantic BaseModel (bare scalars → 400 from Gemini). Use @ai.tool(), not @ai.define_tool().

class WeatherInput(BaseModel):
    city: str

@ai.tool()
async def get_weather(input: WeatherInput) -> str:
    return f'Sunny in {input.city}'

response = await ai.generate(prompt='Weather in Paris?', tools=[get_weather])

Embeddings

from genkit_google_genai import GoogleAI

embedder = GoogleAI.embedding('gemini-embedding-001')
embeddings = await ai.embed(embedder=embedder, content='The sky is blue.')
vector = embeddings[0].embedding

embeddings = await ai.embed_many(
    embedder=embedder,
    content=['The sky is blue.', 'Grass is green.'],
)

Common embedders: googleai/gemini-embedding-001 (text), googleai/gemini-embedding-2 (multimodal: text, image, video). Plain string ids (embedder='googleai/gemini-embedding-001') also work.

Multimodal input goes in a Document:

from genkit import Document

image_embeddings = await ai.embed(
    embedder=GoogleAI.embedding('gemini-embedding-2'),
    content=Document.from_media('data:image/png;base64,...', 'image/png'),
)

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an API key, Needs Python, Needs Node.js

Security

What our scanner noticed· Medium risk

  • Instructions that use the network
  • Downloads piped into a shell

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
Google
Publisher
Google (Official)
Source
google/skills · skills/cloud/developing-genkit-python · commit 2194d3b
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Google.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download developing-genkit-python.zip