Related Pages

Related topics: AI Model Integration, Plugins, and Schema Handling, Core Features: Flows, Dotprompt, Tools, RAG, and Sessions, Developer Tools, CLI, Evaluation, and Telemetry

Genkit Overview and Multi-SDK Architecture

Purpose and Scope

Genkit is an open-source framework for building full-stack AI-powered applications, developed and used in production by Google's Firebase team. The repository hosts SDKs across four languages — JavaScript/TypeScript, Go, Python (Beta), and Dart (Preview) — alongside a unified CLI, a developer UI, and an MCP server. The framework's goal is to abstract model-provider differences behind a consistent API so that engineers can build, test, and deploy AI features without re-learning the integration layer for each new model.

Source: README.md

The framework targets server-side AI logic with seamless client-side helpers and Firebase-based deployment. Core capabilities advertised in the README include text and image generation, type-safe structured output, tool calling, prompt templating (Dotprompt), persisted chat, AI workflows (flows), and retrieval-augmented generation (RAG).

Multi-SDK Architecture

Genkit maintains language SDKs at different maturity levels but shares a common conceptual model across all of them. The README states JavaScript/TypeScript and Go are production-ready with full feature support, Python is Beta with wide coverage, and Dart is Preview with core functionality.

Source: README.md

The Python SDK mirrors the JS/TypeScript surface — flows, tools, prompts, embedders, and retrievers all funnel into a shared registry pattern. The Python README describes a top-level Genkit constructor that accepts plugins and a default model, and exposes decorators (@ai.flow, @ai.tool) plus helper methods (ai.embed(), ai.retrieve()).

Source: py/packages/genkit/README.md Source: py/README.md

flowchart LR
    A[User Application] --> B[Genkit SDK<br/>JS / Go / Python / Dart]
    B --> C[Registry<br/>Flows, Tools, Prompts,<br/>Embedders, Retrievers]
    C --> D[Model Provider Plugins]
    D --> E[Google GenAI]
    D --> F[OpenAI]
    D --> G[Anthropic]
    D --> H[Ollama + others]
    C --> I[Middleware<br/>filesystem, skills, retry]
    C --> J[CLI & Developer UI]
    J --> K[MCP Server]

The model-provider surface is delivered as plugins. The Google GenAI plugin, Anthropic plugin, OpenAI plugin, and Ollama plugin are referenced as the primary integrations, with the model factory (googleAI.model('gemini-flash-latest')) being the typical entry point for model selection.

Source: README.md

Common Concepts Across SDKs

Although the syntax varies, every SDK centers on the same primitives: flows (server-side callable units with input/output schemas), tools (functions the model can invoke), prompts (templated instructions, including .prompt files with YAML frontmatter), embedders (vector representations for RAG), and retrievers (data fetchers used to ground generation).

The Dotprompt sample illustrates the JS surface: .prompt files declare model config, schemas, and variants; partials (_style.prompt) can be composed; and registered Zod schemas are referenced by name from frontmatter. This same .prompt system is available across the JS, Go, and Python SDKs.

Source: js/testapps/prompt-file/README.md

The basic-gemini test app demonstrates the breadth of features exposed through a single plugin: thinking modes, vision input, YouTube video transcription, search grounding, URL context, file search (RAG), tool calling, structured output, and image generation. Each feature is a separate flow that can be invoked through the CLI or developer UI.

Source: js/testapps/basic-gemini/README.md

The @genkit-ai/middleware package ships reusable cross-cutting behavior — filesystem (sandboxed file manipulation tools), skills (auto-loading SKILL.md files into the system prompt), retry, and fallback model chains. Middleware is composed through the use array on a generation call, allowing per-request customization without modifying core SDK code.

Source: js/plugins/middleware/README.md

Tooling, CLI, and MCP Integration

The genkit-cli package provides command-line commands for the full development loop: init (scaffold a project), start (run in dev mode with the Developer UI), flow:run / flow:batchRun / flow:resume (invoke flows), and eval:extractData / eval:run / eval:flow (evaluate quality). The CLI also drives config for environment management.

Source: genkit-tools/cli/README.md

The reflection API is the bridge between running apps and the CLI/UI. It exposes actions, their schemas, and trace results, which the CLI consumes to enable local execution without a separate server.

Source: genkit-tools/common/src/api/reflection.ts

Genkit includes both an MCP client (createMcpHost, createMcpClient) and an MCP server (createMcpServer). The CLI's MCP server lets external agents and IDEs discover flows, run them, inspect traces, and read documentation directly. The published @genkit-ai/mcp package declares a peer dependency on @modelcontextprotocol/sdk ^1.29.0.

Source: js/plugins/mcp/README.md Source: js/plugins/mcp/package.json Source: genkit-tools/cli/src/mcp/README.md

Community Considerations

Several recurring community concerns map directly to architectural seams in this codebase:

• Zod version compatibility (issue #3470, #2758) — Zod is the default schema library for the JS SDK; some Zod 4 features like nullable() and describe() produce schemas that Gemini rejects. This is an active integration risk users should test before pinning a Zod version.
• Dotprompt role handling (issue #3711) — In the Go SDK, multi-message .prompt files were previously flattened to a single user role. Recent Go v1.9.0 fixes address metadata preservation and multipart tool responses, but role fidelity remains a concern to verify.
• Session updateState semantics (issue #1437) — Chat session state behavior differs between JS and Go, with replacement vs. patch semantics causing confusion.
• Provider-specific options (issue #1901) — Features such as Google Search grounding require explicit plugin-level configuration (googleSearchRetrieval) rather than a unified model-config surface.

These are documented here as known integration points; users building cross-SDK pipelines should validate behavior against the specific release they target.

See Also

• Genkit JS SDK (js/genkit/src/) — core runtime and registry
• Plugin reference (js/plugins/) — Google GenAI, Anthropic, OpenAI, Ollama, MCP, middleware
• Python SDK (py/packages/genkit/) — Python runtime mirroring JS API
• CLI & MCP server (genkit-tools/cli/) — developer tooling surface
• Evaluators (py/samples/evaluators/) — quality scoring patterns

Related Pages

Related topics: Genkit Overview and Multi-SDK Architecture, Core Features: Flows, Dotprompt, Tools, RAG, and Sessions

AI Model Integration, Plugins, and Schema Handling

Overview

Genkit is an open-source framework for building AI-powered applications that exposes a unified API across model providers, vector stores, and deployment platforms. Its three concerns — model integration, the plugin system, and schema handling — work together to abstract away provider-specific differences so that application code can describe prompts, structured output, tools, and retrieval in a single, consistent way.

Cross-language support is a first-class goal: Genkit ships SDKs for JavaScript/TypeScript, Go, Python (Beta), and Dart (Preview), each implementing the same conceptual surface (flows, prompts, tools, embedders, retrievers) over a shared Registry (README.md). Plugins are how third-party capabilities — model providers, deployers, evaluators, MCP bridges, and middleware — are wired into the framework.

Plugin Architecture

Plugins are pluggable units registered at Genkit initialization. The root README groups the ecosystem into categories (README.md):

The Go SDK mirrors this pattern. The googlegenai Go plugin exposes a single struct that selects the backend — for example, &googlegenai.GoogleAI{APIKey: "..."} targets the Gemini Developer API while &googlegenai.VertexAI{...} targets Vertex AI — and it unifies access to language, embedding, image, video, and speech models under one surface (go/plugins/googlegenai/README.md).

The Python SDK follows the same registry-driven design: a single Genkit(plugins=[...], model=...) call instantiates flows, tools, prompts, embedders, and retrievers that all funnel through one shared registry (py/README.md).

flowchart LR
    App[Application code] --> Genkit[Genkit Registry]
    Genkit --> M1[Google GenAI plugin]
    Genkit --> M2[Vertex AI plugin]
    Genkit --> M3[Anthropic / Ollama plugins]
    Genkit --> V1[Pinecone / ChromaDB retrievers]
    Genkit --> T1[Tools & MCP]
    Genkit --> MW[Middleware<br/>filesystem, skills]
    M1 --> Gemini[(Gemini API)]
    M2 --> VertexAI[(Vertex AI)]
    T1 --> MCP[MCP Servers]

The MCP plugin (@genkit-ai/mcp, v1.37.0) is the bridge to the Model Context Protocol. It declares support for both client and server use cases, depends on @modelcontextprotocol/sdk ^1.29.0, and ships with an experimental CLI MCP server that exposes list_flows, run_flow, trace retrieval, and documentation lookup as MCP tools (js/plugins/mcp/package.json, genkit-tools/cli/src/mcp/README.md).

Model Integration and Output Formats

The model layer is invoked through a single generate / generateStream API. The basic-gemini sample enumerates the breadth of features exposed through that one entry point (js/testapps/basic-gemini/README.md):

• Simple text generation and streaming
• Retry and fallback middlewares (basic-hi-with-retry, basic-hi-with-fallback)
• Thinking modes (Pro and Flash variants)
• Multimodal input/output (vision, YouTube, screenshot-based tools)
• Search grounding, URL context, and file search (RAG)
• Tool calling (including structured tool calling)
• Structured output with Zod schemas
• Media resolution, image generation (Imagen 3, Gemini 2.5 Pro Image), and TTS

The format-tester sample documents the five canonical output formats that Genkit normalizes across providers — text, json, array, jsonl, and enum — and stress-tests them across vertexai/gemini-2.5-pro, vertexai/gemini-2.5-flash, googleai/gemini-2.5-pro, googleai/gemini-2.5-flash, and Vertex AI Model Garden Claude 3.5 Sonnet (js/testapps/format-tester/README.md). Normalizing these formats is the bridge that lets the same prompt file work across vendors.

RAG extends the model surface with retrievers. The rag sample shows the same askQuestionsAboutX pattern switching backends between Pinecone, ChromaDB, a local dev vector store, and a Firebase-backed store, with a pdfQA flow that chunks and indexes PDF documents (js/testapps/rag/README.md). Vertex AI also exposes a semantic reranker that can be invoked via the rerank helper and a vertexai/reranker reference (js/testapps/vertexai-reranker/README.md).

A common integration need flagged by the community is exposing Gemini-specific options such as googleSearchRetrieval directly on generateStream's config block. Today users typically wrap these as model-level tools or pass them through plugin config, and the issue tracker shows active discussion of a first-class google_search option (Issue #1901).

Schema Handling with Zod (and Known Pitfalls)

Schemas are the contract between application code, prompts, and models. Genkit standardizes on Zod for the JS/TS SDK: prompt files can reference a Recipe Zod schema, and the generated model output is validated and typed against it (js/testapps/prompt-file/README.md). Dotprompt files (.prompt with YAML frontmatter) layer model config, input/output schemas, variants, and partials on top of the same schema primitives.

The community has surfaced two important limitations of the Zod integration that affect how schemas are translated into provider-native structured-output formats:

1. Zod 4 compatibility — Zod 4 schemas cannot yet be passed to @genkit-ai/core, and the request is to update dev dependencies to accept the newer version (Issue #3470).
2. Translation gaps to Gemini — The JSON Schema produced from Zod is sometimes rejected by the Gemini API for constructs like nullable() and describe(). The complaint is that "the documentation gives the impression that Zod integrates fully with GenKit but that does not seem to be the case" (Issue #2758). When hitting these gaps, a practical workaround is to keep Zod schemas minimal (avoid nullable/describe on the output side) and rely on a parser step for richer types.

Closely related to schema handling is the prompt role contract enforced by Dotprompt. In the Go SDK, rendering a multi-message .prompt always uses the user role and ignores Dotprompt-defined roles, which is tracked as a bug (Issue #3711). Until that is fixed, multi-role prompts should be authored programmatically rather than via Dotprompt frontmatter in Go.

See Also

• Dotprompt Documentation — .prompt file syntax, partials, and variants.
• Tool Calling — defining tools and wiring them into generate.
• RAG — retrievers, indexers, and the pdfQA pattern.
• Deployment — Express, Firebase, and Cloud Run targets.
• Model Context Protocol — exposing flows and tools to MCP-aware agents.

Related Pages

Related topics: Genkit Overview and Multi-SDK Architecture, AI Model Integration, Plugins, and Schema Handling

Core Features: Flows, Dotprompt, Tools, RAG, and Sessions

Genkit is a cross-language framework for building AI-powered applications with type-safe flows, structured outputs, and integrated observability. The library is offered as SDKs for JavaScript/TypeScript, Go, Python (Beta), and Dart (Preview) with consistent APIs and capabilities across all supported languages. Source: README.md. The Python SDK mirrors the JS/TS SDK and is described as "a framework for building AI-powered applications with type-safe flows, structured outputs, and integrated observability." Source: py/README.md.

This page documents the five core primitives that compose nearly every Genkit application: Flows, Dotprompt, Tools, Retrieval-Augmented Generation (RAG), and Sessions.

Architectural Overview

The five primitives interlock around a central registry that routes calls to model plugins, embedders, retrievers, and servers.

flowchart LR
    App[Application Code] --> F[Flows<br/>ai.defineFlow]
    F --> P[Prompts<br/>Dotprompt / ai.definePrompt]
    F --> T[Tools<br/>ai.defineTool]
    F --> R[Retrievers<br/>ai.defineRetriever]
    F --> S[Sessions / State<br/>chat sessions]
    P --> LLM[Model Plugins<br/>Google AI, Vertex, Anthropic, Ollama]
    T --> LLM
    R --> VS[(Vector Stores<br/>Pinecone, Chroma, Dev)]
    S --> F
    F --> Tr[Tracing / Dev UI]

Flows

Flows are executable, strongly typed functions defined via ai.defineFlow. They accept a typed input schema and return a typed output, and they are the unit at which Genkit produces traces and exposes endpoints to the Developer UI. Source: js/testapps/menu/README.md ("wrap your llm calls and other application code into flows with strong input and output schemas").

Flows are invoked manually through the Dev UI for testing, or they are exposed over HTTP for deployment. The MCP CLI exposes two flow-oriented tools — list_flows and run_flow — that an MCP-compatible agent can use to discover and execute flows against the input schema each flow declares. Source: genkit-tools/cli/src/mcp/README.md.

In the Python SDK the same concept is exposed as the @ai.flow decorator on functions defined inside a Genkit(plugins=[...]) instance. Source: py/README.md.

Dotprompt

Dotprompt is Genkit's executable prompt template format: .prompt files with YAML frontmatter and Handlebars-style bodies. The frontmatter carries model configuration, input/output schemas, and metadata; the body carries the template. Source: js/testapps/prompt-file/README.md.

Capabilities demonstrated in the prompt-file sample app:

Source: js/testapps/prompt-file/README.md.

The Python samples include a prompts directory that exercises the same features — .prompt files, helpers, variants, and streaming. Source: py/samples/README.md.

Community note: Issue #3711 reports that the Go SDK's prompt renderer always assigns the user role, ignoring roles defined inside a multi-message Dotprompt template. Source: genkit-ai/genkit#3711.

Tools

Tools are typed functions that a model can invoke during a generation. The basic-gemini sample demonstrates both simple streaming tool use (weather plus unit conversion) and structured tool calling where the tool returns a structured payload. Source: js/testapps/basic-gemini/README.md. The Anthropic plugin test app further exercises tools across stable and beta runners, including prompt caching and document/PDF handling. Source: js/testapps/anthropic/README.md.

Genkit also exposes a full Model Context Protocol (MCP) integration: createMcpHost lets a Genkit app consume MCP servers as namespaces of tools and prompts, while createMcpServer exposes Genkit tools and prompts to MCP clients. Source: js/plugins/mcp/README.md. The GitHub PR explainer sample is a worked example: a Genkit flow spins up the GitHub MCP server, invokes its tools, and asks a model to produce a TL;DR. Source: go/samples/mcp-git-pr-explainer/README.md.

Retrieval-Augmented Generation (RAG)

RAG in Genkit pairs a retriever (which queries a vector store) with a generator (the model call). The RAG sample app wires up three backends — Pinecone, ChromaDB, and the local dev vector store — and ships indexing flows for each. Source: js/testapps/rag/README.md. A separate multimodal sample indexes PDFs (text + images) and videos into Pinecone or Chroma and exposes QA flows over the indexed content. Source: js/testapps/multimodal/README.md.

Retrieval can also be served by remote systems. The Vertex AI reranker sample indexes documents with Vertex AI embeddings and re-orders the retrieved set with a Vertex reranker before returning it to the caller. Source: js/testapps/vertexai-reranker/README.md.

The Menu sample progresses through five iterations, and step four introduces a vector database so that menu items retrieved by similarity are injected into the prompt before generation. Source: js/testapps/menu/README.md.

Sessions and State

The Menu sample iterates a third step that adds session history so the model can conduct a multi-turn chat rather than answering one-shot queries. Source: js/testapps/menu/README.md. The Python sample set includes a dedicated tool-interrupts directory covering respond_example.py (a trivia flow) and approval_example.py (a bank-approval flow that interrupts for human input and then resumes). Source: py/samples/README.md.

Community note: Issue #1437 reports that session.updateState() currently replaces the entire state object instead of patching the provided keys — calling updateState({ userName: 'God' }) overwrites the rest of the state. Source: genkit-ai/genkit#1437.

Known Limitations Reflected in Community Issues

A few recurring pain points surface across the core primitives:

• Zod compatibility — Issue #3470 asks for zod@4 support in @genkit-ai/core, and #2758 notes that some Zod helpers (nullable(), describe()) produce schemas that the Gemini API rejects. Source: genkit-ai/genkit#3470, #2758.
• Google search option — Issue #1901 asks for an officially exposed google_search (Google Search Retrieval) config on Gemini calls; users currently wire it through config.googleSearchRetrieval. Source: genkit-ai/genkit#1901.
• Dotprompt roles in Go — #3711 (above). Source: genkit-ai/genkit#3711.
• Session state semantics — #1437 (above). Source: genkit-ai/genkit#1437.

See Also

• Plugin Ecosystem and Deployment — model, vector-store, and deployment plugins.
• Developer Tools and the Dev UI — genkit start, tracing, and the MCP CLI.
• Structured Output and Formats — JSON, enum, array, and JSONL output handling demonstrated by the format-tester app. Source: js/testapps/format-tester/README.md.

Related Pages

Related topics: Genkit Overview and Multi-SDK Architecture, Core Features: Flows, Dotprompt, Tools, RAG, and Sessions

Developer Tools, CLI, Evaluation, and Telemetry

Genkit's developer experience is delivered through three coordinated pieces: a Node-based CLI, a reflection API embedded in the user's app, and a browser-based Developer UI. They let a developer run flows, inspect traces, and grade model outputs without bolting on bespoke observability infrastructure.

CLI Command Surface

The CLI entry point in genkit-tools/cli/src/cli.ts defines a startCLI function that registers a Commander program named genkit and installs a preAction hook on every command. The hook records a RunCommandEvent for each invocation (with binary or node as the runtime) and, on first run, calls notifyAnalyticsIfFirstRun to inform the user that anonymous usage telemetry is being collected. Two global flags control the developer-facing behavior: --no-update-notification disables the version banner, and --non-interactive skips the first-run prompt. Source: genkit-tools/cli/src/cli.ts:1-100.

The exported command set includes:

• start / startFlutter — launch the Developer UI alongside a Node or Flutter app.
• flow:run — invoke a registered flow with a JSON or streaming payload.
• eval:flow / eval:run / eval:extract-data — drive the evaluation harness (ad-hoc datasets, saved datasets, and trace-derived datasets respectively).
• init:ai-tools — scaffold a starter project.
• mcp — expose Genkit actions through the Model Context Protocol.
• docs:list / docs:read / docs:search — browse the bundled documentation corpus.
• trace:get / trace:list — inspect span data for debugging.
• config — manage genkit configuration (e.g., plugin enablement).
• dev:test-model — probe a model plugin from the terminal.

Source: genkit-tools/cli/src/cli.ts:1-100.

Developer UI and the Reflection API

The Dev UI is the CLI's flagship workflow. The JavaScript quickstart in js/genkit/README.md shows the canonical boot command:

npx genkit start -- npx tsx src/index.ts

The Dev UI then lets the developer "visually test flows, inspect traces, and experiment with prompts" from a browser. Source: js/genkit/README.md.

The CLI does not import your flow code directly. Instead, the Dev UI talks to your app process over an in-process HTTP control plane called the Reflection API. Its OpenAPI spec is generated from genkit-tools/common/src/api/reflection.ts, which describes the surface as "A control API that allows clients to inspect app code to view actions, run them, and view the results." Source: genkit-tools/common/src/api/reflection.ts:1-30. The same reflection surface is what enables patterns like the "exercise flows and watch spans appear in the Dev UI" demos in the menu sample, where each iteration ships an example.json payload for replay. Source: js/testapps/menu/README.md.

flowchart LR
  User[Developer] -->|runs| CLI[genkit CLI]
  CLI -->|spawns| App[User app process]
  App -->|hosts| RefAPI[Reflection API<br/>HTTP control plane]
  RefAPI -->|actions, traces, schemas| CLI
  CLI -->|live preview| DevUI[Developer UI<br/>in browser]
  DevUI -->|commands| CLI
  RefAPI -->|spans| Telemetry[Telemetry exporters]

Evaluation

The CLI exposes evaluation as a first-class workflow rather than a one-off script. eval:run executes a saved dataset against a flow, eval:flow runs an ad-hoc dataset, and eval:extract-data derives a fresh dataset from a flow's existing trace data. The Python SDK README describes evaluation as part of the same flow/tool/prompt surface, indicating that the eval plugin reaches into the same registry the reflection API exposes, so dataset rows can be replayed as live flow invocations and graded by pluggable evaluators. Source: py/README.md. The cross-language format tester sample also depends on this harness to assert that every model × output-format combination in its test matrix is exercised and reported as pass/fail. Source: js/testapps/format-tester/README.md.

Telemetry

Two distinct telemetry mechanisms are at play. At the CLI level, every command records a RunCommandEvent and a one-time first-run notice informs the user that anonymous usage data is being collected; both can be suppressed with --no-update-notification and --non-interactive. Source: genkit-tools/cli/src/cli.ts:1-100.

At the application level, the top-level README points developers at the @genkit-ai/google-cloud plugin for production observability — span trees, latency, token counts — which the Dev UI can then render in real time. Source: README.md. Together, the two layers give developers lightweight local feedback in the Dev UI and a path to full production telemetry through the same action registry, without forcing teams to re-instrument their flows.

See Also

• README.md — top-level overview of Genkit's features and the Cloud observability story.
• py/README.md — Python SDK architecture and the registry that the eval plugin reuses.
• js/genkit/README.md — JavaScript/TypeScript quickstart with the Dev UI bootstrap command.
• genkit-tools/cli/src/cli.ts — CLI source, command surface, and pre-action telemetry hook.

Doramagic Pitfall Log

Found 11 structured pitfall item(s), including 1 high/blocking item(s). Top priority: Security or permission risk - Security or permission risk requires verification.

1. Security or permission risk: Security or permission risk requires verification

• Severity: high
• Finding: Project evidence flags a security or permission risk. Review the linked source before relying on this workflow.
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: community_evidence:github | https://github.com/genkit-ai/genkit/issues/2380

2. Installation risk: Installation risk requires verification

• Severity: medium
• Finding: Project evidence flags a installation risk. Review the linked source before relying on this workflow.
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: community_evidence:github | https://github.com/genkit-ai/genkit/issues/5597

3. Configuration risk: Configuration risk requires verification

• Severity: medium
• Finding: Project evidence flags a configuration risk. Review the linked source before relying on this workflow.
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: community_evidence:github | https://github.com/genkit-ai/genkit/issues/5542

4. Capability evidence risk: Capability evidence risk requires verification

• Severity: medium
• Finding: README/documentation is current enough for a first validation pass.
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: capability.assumptions | https://github.com/genkit-ai/genkit

5. Maintenance risk: Maintenance risk requires verification

• Severity: medium
• Finding: Project evidence flags a maintenance risk. Review the linked source before relying on this workflow.
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: evidence.maintainer_signals | https://github.com/genkit-ai/genkit

6. Security or permission risk: Security or permission risk requires verification

• Severity: medium
• Finding: no_demo
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: downstream_validation.risk_items | https://github.com/genkit-ai/genkit

7. Security or permission risk: Security or permission risk requires verification

• Severity: medium
• Finding: no_demo
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: risks.scoring_risks | https://github.com/genkit-ai/genkit

8. Security or permission risk: Security or permission risk requires verification

• Severity: medium
• Finding: Project evidence flags a security or permission risk. Review the linked source before relying on this workflow.
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: community_evidence:github | https://github.com/genkit-ai/genkit/issues/817

9. Security or permission risk: Security or permission risk requires verification

• Severity: medium
• Finding: Project evidence flags a security or permission risk. Review the linked source before relying on this workflow.
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: community_evidence:github | https://github.com/genkit-ai/genkit/issues/5598

10. Maintenance risk: Maintenance risk requires verification

• Severity: low
• Finding: issue_or_pr_quality=unknown。
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: evidence.maintainer_signals | https://github.com/genkit-ai/genkit

11. Maintenance risk: Maintenance risk requires verification

• Severity: low
• Finding: release_recency=unknown。
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: evidence.maintainer_signals | https://github.com/genkit-ai/genkit

Community Discussion Evidence

Doramagic exposes project-level community discussion separately from official documentation. Review these links before using genkit with real data or production workflows.

• Support Prompt Caching for Anthropic - github / github_issue
• feat(go/plugins/anthropic): support prompt caching (cache_control) - github / github_issue
• [[Go] Add advanced features to Ollama plugin](https://github.com/genkit-ai/genkit/issues/2380) - github / github_issue
• [[Go] Add structured output support in Ollama plugin](https://github.com/genkit-ai/genkit/issues/4788) - github / github_issue
• feat(*): Testing Modules - github / github_issue
• feat: Python P0 model parity june 2026 - github / github_issue
• Genkit Go v1.9.0 - github / github_release
• Genkit JS and CLI 1.37.0 - github / github_release
• Genkit Python SDK v0.7.0 - github / github_release
• @genkit-ai/[email protected] - github / github_release
• @genkit-ai/[email protected] - github / github_release
• @genkit-ai/[email protected] - github / github_release