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/agents.md

Agents (Beta)

Preview API under genkit.agent.

Turn a model + tools into a durable conversation — history, typed state, approvals, branches, and background work.

Deeper topics: sessions · HITL · branching · background · state · artifacts · custom · HTTP

Define an agent

from pydantic import BaseModel

from genkit import Genkit
from genkit_google_genai import GoogleAI
from genkit.agent import InMemorySessionStore

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


class WeatherInput(BaseModel):
    location: str


class WeatherOutput(BaseModel):
    weather: str
    temperature: str


@ai.tool(name='getWeather', description='Get weather for a city.')
async def get_weather(input: WeatherInput) -> WeatherOutput:
    return WeatherOutput(weather='Sunny', temperature='21°C')


agent = ai.define_agent(
    name='weatherAgent',
    model='googleai/gemini-flash-latest',
    system='Weather assistant. Use getWeather for weather questions.',
    tools=[get_weather],
    store=InMemorySessionStore(),  # omit to manage history yourself
)

Options worth knowing: use (middleware), state_schema, max_turns (tool loop depth per user message), transforms. Dotprompt agents: ai.define_prompt_agent. Full control: define_custom_agent.

Tool parameters should be a small Pydantic model — even for one field. Empty inputs need an empty subclass, not bare BaseModel.

Middleware

Register Middleware() once, then pass instances in use=[...].

  • Filesystem — list_files / read_file. Writes stay off until allow_write_access=True. Paths are relative to root_dir.

  • ToolApproval — tools in allowed_tools run; everything else pauses for a human. List write/artifact tools if they should run freely.

  • Skills — load skills/<name>/SKILL.md and expose use_skill.

  • Retry — retries flaky model HTTP calls. Tool failures are different: return a soft-error payload the model can read.

from genkit_middleware import Middleware, ToolApproval, Filesystem, Skills, Retry
from genkit.agent import FileSessionStore

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

coding_agent = ai.define_agent(
    name='codingAgent',
    model='googleai/gemini-flash-latest',
    system='Coding assistant. Use list_files/read_file/write_file/edit_file.',
    use=[
        ToolApproval(allowed_tools=['list_files', 'read_file', 'use_skill']),
        Filesystem(root_dir='./workspace', allow_write_access=True),
        Skills(skill_paths=['./skills']),
        Retry(),
    ],
    store=FileSessionStore('./.snapshots'),
    max_turns=30,
)

For typed session fields with middleware, update state from tools via ai.current_session() — state. Declaring state_schema alone does not fill chat.state.

Chat

chat = agent.chat()

res = await chat.send('Weather in Tokyo?')
print(res.text, res.snapshot_id)

turn = chat.send_stream('What about Paris?')
async for chunk in turn.stream:
    if chunk.text:
        print(chunk.accumulated_text, end='\r', flush=True)
final = await turn.response

Send returns a response. Stream returns a turn with .stream and .response. After an interrupt, use resume / resume_stream.

You can await the response without reading every chunk. One send at a time per chat.

To reopen a stored conversation, use load_chat (not chat(snapshot_id=...), which only attaches a resume handle):

resumed = await agent.load_chat(snapshot_id=res.snapshot_id)
await resumed.send('What city did I ask about?')

Verify an agent from the CLI (flow:run)

genkit flow:run only runs flows, not agents, so you can't flow:run an agent directly. To exercise an agent from the CLI (e.g. a quick, self-terminating check), wrap one turn in a throwaway flow and run that:

@ai.flow()
async def try_weather_agent(message: str) -> str:
    return (await agent.chat().send(message)).text

# genkit flow:run try_weather_agent '"Weather in Tokyo?"' -- uv run src/main.py

Without a store

Skip store when your app owns history. Ids stay None — pass messages, state, and artifacts into the next chat(...):

agent = ai.define_agent(
    name='echoNoStore',
    model='googleai/gemini-flash-latest',
    system='Echo assistant. Answer briefly and remember context.',
)

chat = agent.chat()
await chat.send('My name is Ada. Remember it.')

resumed = agent.chat(
    messages=chat.messages, state=chat.state, artifacts=chat.artifacts
)
await resumed.send('What is my name? One word.')

Add a store when the server should own history, or when you need branching and detach. Interrupts work either way.

Auth

Put identity on the server with serve_agent and a FastAPI dependency. The remote client only forwards credentials. See HTTP.

Prompt agents

define_prompt_agent(name=...) uses the same name for the agent and the .prompt file stem. Keep preamble inputs stable for the chat — put dynamic fields in user messages or tools.

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