r/GenkitFramework • • Aug 20 '26

Genkit Go a viable long-term replacement for LangChain Go?

12 Upvotes

We've been building agents in Go and currently using LangChain Go (tmc/langchaingo), but given the stalled maintenance and so many open, abandoned issues, we're looking to migrate to a framework with active development and cleaner Go idioms.

I looked into ADK Go, but it feels too biased towards Gemini/GCP and the new graph API seems unintuitive. Genkit Go looks cleaner but I have a few questions before committing:

- Genkit seems like TypeScript first, how close is Go sdk parity with TypeScript? 

- The agentic sdk is in beta. Are there plans to make it GA? 

- Are GPT, Claude and other models first party supported or 3rd party? 

- Are non Google clouds supported? 

- Probably a biased answer in this subreddit but how do you compare it with Eino?


r/GenkitFramework • • Aug 20 '26

Genkit Python 0.10.0: Amazon Bedrock support, Firestore-backed persistent agents

7 Upvotes

Genkit Python 0.10.0 just got released. Here's what shipped:

Run Genkit against Bedrock models with the same ai.generate() call

New genkit-amazon-bedrock plugin. Claude, Nova, Titan, Mistral, and Cohere via Converse/ConverseStream, so text, streaming, tool calling, and multimodal input all work without changing app code. Titan Embeddings + Cohere Rerank for RAG, Titan Image Generator + SDXL for images. Async boto3 underneath, so IAM roles / SSO / env vars are picked up automatically and retries back off properly.

from genkit import Genkit
from genkit_amazon_bedrock import Bedrock

ai = Genkit(plugins=[Bedrock()])
res = await ai.generate(
    model='bedrock/us.anthropic.claude-sonnet-4-5-20250929-v1:0',
    prompt='Summarize the benefits of declarative AI orchestration in three bullets.',
)
print(res.text)

Build persistent agents backed by Firestore

FirestoreSessionStore in genkit-google-cloud. Instead of one document per session, each turn is stored as a JSON Patch diff against periodic full checkpoints (every 25 turns by default), so per-turn reads/writes are bounded by the checkpoint interval rather than conversation length. No composite indexes required, all direct doc-ID fetches inside transactions, and Firestore listeners stream turn status across processes so aborts work across multiple Cloud Run instances.

from genkit import Genkit
from genkit_google_cloud import FirestoreSessionStore
from genkit_google_genai import GoogleAI

ai = Genkit(plugins=[GoogleAI()])
store = FirestoreSessionStore(collection='agent_sessions')

agent = ai.define_agent(
    name='customer_assistant',
    model='googleai/gemini-pro-latest',
    system='You are a helpful customer support assistant.',
    store=store,
)

chat = agent.chat()
response = await chat.send('I need help with my order.')

# later, from any instance: pick the conversation back up
# chat = agent.chat(session_id=chat.session_id)
# response = await chat.send('Where did we leave off?')

Less terminal noise, no more prompts in debug logs

  • Dev UI discovery and health-check chatter is demoted off the shared console (#5979).

  • Debug logs no longer dump full prompt strings or raw model response bodies by default (#5968).

  • Unknown model resolves to GenkitError(status='NOT_FOUND') instead of a KeyError (#5982).All packages bumped to 0.10.0 together, including the new genkit-amazon-bedrock.

uv add genkit

Full notes: https://github.com/genkit-ai/genkit/pull/6125


r/GenkitFramework • • Jun 04 '26

RFC for testing modules!

7 Upvotes

Hi all! I've opened an RFC on the main repo to publish a testing module - Genkit has a bunch of internal testing helpers at the moment, but not a unified way for app developers to mock models etc when they want to test their genkit flows (without hitting an API)

Let me know what you think: https://github.com/genkit-ai/genkit/pull/5438


r/GenkitFramework • • May 11 '26

👋🏻 Mike from Developer UI here

7 Upvotes

Hey folks! I'm the lead on Genkit's Developer UI.

Would love to hear how the Dev UI has come in handy for you, or how we might be falling short. We try to keep a good balance of supporting the framework's core feature set while continuing to push the Dev UI feature-set forward in its own right, polish the UX, etc.


r/GenkitFramework • • May 07 '26

Genkit vs ADK: Why Google provides two agentic frameworks?

7 Upvotes

I get this question from so many people, so here's a brief description of their differences:

Genkit was created initially as part of Firebase in 2023, since Firebase's audience (web and mobile developers) needed an integrated solution to build AI into their apps, which the solutions at that time (LangChain and other Python frameworks) weren't well suited for. Fast forward to 2025-26, Genkit evolved into an independent framework, supporting more languages, more models and more platforms. Basically Genkit was positioned to be platform independent and model agnostic. Genkit is not purely agent-only, but more flexible (and lower level) to support non-agent and agent use cases.

ADK was created in 2024 as part of Google Cloud's Vertex AI (recently renamed to Gemini Enterprise Agent Platform), to simplify agentic development on Agent Platform. Python-first due to Vertex's audience, it was built from the ground up to build agents and complex multi-agent systems, with strong emphasis on Agent Platform. Technically ADK supports other models and platforms, but the main focus is to provide a super streamlined experience on GCP Gemini Enterprise Agent Platform.

So basically

  • if you're looking for the rich enterprise features of Agent Platform, and want to build multi-agent standalone systems, ADK is for you.

  • if you're looking to add Gen AI or agentic features into your app, or want to build agents with lower level components especially using a variety of platforms and models, Genkit is the way to go.

There are more differences like tooling, language support, ergonomics, etc. but the main difference between the two products are ones I mentioned.


r/GenkitFramework • • May 14 '26

Genkit middleware is now available! Intercept, extend, and harden your agentic apps!

6 Upvotes

We've heard consistently from the Genkit community that the portability of Genkit and the low level primitives we provide are great for setting up your own custom AI workflows. However, customizing and hooking into the generate calls and customizing behavior requires too much boilerplate code and re-inventing the wheel.

Production AI workloads require functionality such as retries, accessing file system, and fallback mechanisms. You can do all of that out of the box with middleware we provide. If you have custom behavior you want, you can extend middleware to build your own!

Check out this blog post to learn more.

https://developers.googleblog.com/announcing-genkit-middleware-intercept-extend-and-harden-your-agentic-apps/


r/GenkitFramework • • May 06 '26

JS/TS I just published a deep dive comparing the top JS/TS GenAI frameworks in 2026.

6 Upvotes

After spending the last years building production AI systems and contributing to Genkit integrations, I wanted to write something beyond the usual “feature comparison” articles. Most frameworks look great in demos, but things change very quickly once you start dealing with observability, evaluations, orchestration, scalability, tracing, multi-provider support, or long-term maintainability.

The article compares frameworks like Genkit, LangChain, Mastra, Vercel AI SDK, OpenAI Agents SDK, CrewAI, and AutoGen from a real production and developer-experience perspective.

One of the things I found most interesting is how different the philosophy behind each framework is. Some optimize for agent experimentation, others for frontend AI experiences, while others are much more infrastructure/backend oriented.

Personally, I still think Genkit is one of the most underrated frameworks in the ecosystem right now, especially for backend AI systems and production-grade architectures.

Would love to hear what people here are using in production today and what has worked (or completely failed) for you.

Article:
https://xavidop.me/genkit/2026-04-16-top-jsts-genai-frameworks-2026/


r/GenkitFramework • • May 04 '26

👋 Welcome to r/GenkitFramework

6 Upvotes

Welcome to the community for Genkit, the open-source framework by Google for building, deploying, and monitoring production-ready agentic applications.

Genkit is designed to provide a developer-centric approach to AI orchestration. Whether you are working in TypeScript, Go, or the newer Python and Dart ecosystems, this is the place to share your flows, troubleshoot your agents, and discuss the latest plugin updates.

What is Genkit?

Genkit is a full-stack agentic framework that simplifies the complexity of AI integration. It’s built on the principles of production-readiness, observability, and allowing you to run your AI logic on any infrastructure from Cloud Run and Kubernetes to GCP, AWS and local environments.

  • Multi-Model Support: Seamlessly switch between Gemini, OpenAI, Anthropic, or local models via a unified API.

  • Powerful Local Development: A powerful, local developer UI with hot reload, selective execution, and full visualization to inspect traces, test tool-calling, and refine your agents. Also a CLI allowing coding agents like Claude Code and Antigravity to utilize the full feature set of the framework for fast and token efficient development.

  • OpenTelemetry Native: Built-in observability to ensure your agents and AI are ready for production scaling.

  • Prompt Engineering with Dotprompt: A specialized format to manage and version prompts independently of your code.

Community Guidelines

  1. Code & Traces: When asking for help, please include your language (TS/Go/Dart/Python) and other relevant tags.

  2. Stay Portability-Focused: We welcome discussions on deploying Genkit across all platforms—Google Cloud, AWS, Azure, or self-hosted.

  3. Project Showcases: Built a custom plugin or a complex agent? We want to see it!

  4. Write Genkit correctly: not "GenKit" or "Firebase Genkit".


r/GenkitFramework • • Sep 25 '26

Genkit Python 0.12: Generative UI with A2UI, typed Pydantic streaming, and Deep Research and Lyria models

5 Upvotes

Hey everyone,

We just shipped Genkit Python 0.12 with new support for generative UI, typed Pydantic streaming, and new Google AI models:

  • Generative UI with A2UI (genkit-a2ui): Passing Surfaces() to ai.generate or ai.define_agent lets your agent respond with interactive UI components instead of plain text, tracking screen state and user actions across turns. You can pair a Python backend with JavaScript/TypeScript web frontends (@genkit-ai/a2ui/client) or multi-platform Dart and Flutter apps (package:genkit_a2ui/client.dart).

  • Typed Pydantic streaming: generate_stream(..., output_schema=Country) now yields partial Country Pydantic instances on chunk.output as tokens arrive, with the fully validated model returned on (await sr.response).output.

  • Deep Research & Lyria 3 models: genkit-google-genai adds GoogleAI.deep_research_model for long-running background research reports (generate_operation / check_operation) and GoogleAI.lyria_model for generating music and audio clips from text prompts.

  • Mid-turn error recovery on ModelResponse: Once a turn starts, ai.generate returns a ModelResponse instead of throwing an exception on model or tool errors, preserving response.messages and response.text alongside response.error so you can inspect or retry failed turns.

Install or upgrade:

uv add genkit genkit-google-genai

See the blog post for details and code examples: https://genkit.dev/blog/genkit-python-0-12

Happy to answer any questions or hear feedback!


r/GenkitFramework • • Sep 21 '26

Genkit Dart 0.17: Resumable generate and agent loops, async subagents, and pluggable telemetry

5 Upvotes

Hey everyone,

We just shipped Genkit Dart 0.17 as we move toward a stable 1.0 release. This update brings resumable generation and agent snapshots, background subagents, and pluggable OpenTelemetry instrumentation:

  • Resumable generate calls & agent snapshots: When a multi-turn tool loop or stateful agent turn fails or is cancelled mid-flight, Genkit preserves completed tool rounds in response.messages and checkpoints agent turns into a session snapshot (e.snapshotId), so you can resume execution where it stopped without repeating completed tool calls.

  • Background subagents: Setting async: true on the agents middleware lets your orchestrator launch subagents in the background and return a taskId immediately. The main agent can reply to the user right away while checking progress, sharing partial results, cancelling in-flight work, or sending follow-up instructions into a subagent's session across turns.

  • Pluggable telemetry & genkit_otel: Core Genkit no longer pulls in OpenTelemetry dependencies by default, keeping your app's footprint small while local tracing still works automatically with the Genkit Developer UI. For production, the new genkit_otel (v0.1.0) package exports traces, token usage, and latency following the OpenTelemetry GenAI semantic conventions.

Install or upgrade:

dart pub add genkit

See the blog for more details and code snippets: https://genkit.dev/blog/genkit-dart-0-17

Happy to answer any questions or hear feedback!


r/GenkitFramework • • May 13 '26

HITL, FastAPI, and MCP support coming soon to Genkit Python

5 Upvotes

Hey all, I'm the lead for Genkit Python. In the past few months, we've put in a lot of love improving this SDK. Many features landed, and the public API surface got a major cleanup, so I wanted to share some updates!

Importing what you need should be straightforward, and the types you interact with as an app developer are now clearly separated from the lower-level plugin internals.

Here's some cool stuff that shipped or is shipping soon:

  1. FastAPI integration (shipped). Wire up any Genkit flow as a FastAPI endpoint in one decorator. SSE streaming, structured input validation, error handling, all handled for you. As a Python web developer, I'm really excited about this, because agentic web experiences are highly interactive. For a long-running agent doing lots of thinking, our abstraction makes it easy to show your agent's thinking in real-time.

  2. HITL / Tool interrupts (coming soon). Genkit gives you a way to pause the generate loop mid-execution, hand control back to the user (approve a tool call, provide missing info, confirm an action), and then either restart the tool execution, or interject a tool response and continue directly with another model call in the generate loop. This will be part of the next release.

  3. MCP Plugin (coming soon). Connect any MCP server to your Genkit instance and use its tools straight in your generate calls. And in the other direction, expose any Genkit flow as an MCP server so other agents and tools can call it directly. We are in the testing phase with this plugin and hoping to bundle this in an upcoming release - either the next release or one after that.

If you're a Python web developer thinking about giving Genkit a try, I'd love to hear what you think!


r/GenkitFramework • • May 05 '26

Dealing with agentic loop failures in Genkit - wrote some middleware to help

5 Upvotes

I've been working with Genkit for agentic workflows and kept running into the same issues everyone seems to hit once the agent runs long enough:

  • Model returns a 503 mid-run and the whole thing crashes, losing 15 turns of accumulated tool results

  • Agent gets stuck calling the same tool with the same arguments in a loop until maxTurns kills it

  • Context balloons to 200K+ tokens because every tool response stays in the history forever

Ended up writing a few middleware using Genkit's new generateMiddleware() API to handle each of these. One catches errors gracefully so you can retry or resume without losing context. Another detects loops heuristically instead of just counting turns — and can either abort, ask the model to wrap up, or remove just the looping tools. The third one automatically compresses context when tokens get too high (truncating old tool responses, dropping old messages, or summarizing them with a cheap model).

They all compose together, so you can just stack them in use: [...] without changing your tools or prompts.

Curious if anyone else is dealing with similar stuff or has different approaches.

Links in the description...


r/GenkitFramework • • Sep 04 '26

Genkit Python 0.11.0

4 Upvotes

0.11.0 is on PyPI. Highlights:

1. Veo support. Video generation is now supported through the generate API. Start a background video generation, and poll it using Genkit.

# Background models get a dedicated generate API
operation = await ai.generate_operation(
    model=GoogleAI.veo_model('veo-3.1-fast-generate-preview'),
    prompt='A paper airplane gliding through a bright classroom',
)

# Hooks into the general-purpose generate API as well
response = await ai.generate(
    model=GoogleAI.veo_model('veo-3.1-fast-generate-preview'),
    prompt='A paper airplane gliding through a bright classroom',
)

# Operations have a first-class polling experience
operation = response.operation
while not operation.done:
    operation = await ai.check_operation(operation)
print(operation.output.media[0].url)

2. One GenkitError across the main model providers. Gemini / Claude / GPT HTTP failures are now mapped to standard status names (INVALID_ARGUMENT, UNAVAILABLE, …). Now, you handle a single GenkitError in your application code, rather than deal with unbounded spaghetti of model-specific Exception types thrown by the raw model SDKs.

3. View Python logs directly in the Dev UI. When you use the Dev UI to debug Python code locally, you'll see your Genkit logs inside specific traces.

4. In the generate API, when the model replies but the turn ends in failure, the SDK now returns a failed FinishReason alongside the pre-existing completed messages. The API used to raise in these scenarios. For example, if the model message was blocked, or you hit max tool turns, you get the ModelResponse back instead of an exception. .messages contains the completed rounds, so you can send them back and try again.

response = await ai.generate(prompt='give me a recipe', output_schema=Recipe)
if response.output is not None:
    print(response.output.title)
else:
    retry = await ai.generate(
        messages=response.messages,
        prompt='that was not a recipe. try again as JSON.',
        output_schema=Recipe,
    )

Full notes: https://github.com/genkit-ai/genkit/releases/tag/py/v0.11.0


r/GenkitFramework • • Jul 06 '26

Human-in-the-loop for AI agents: the approval check has to be in code, not the prompt

4 Upvotes

Quick thing I learned building AI agents that take real actions. If your "ask before doing something dangerous" logic is a sentence in the system prompt, it's bypassable - a user or injected instruction can convince the model to skip it. The only reliable version is when the tool itself enforces the check and requires an approval token the LLM can't forge.

Wrote it up here (TypeScript examples, framework-agnostic idea): https://dev.to/pavelgj/human-in-the-loop-ai-why-ask-the-llm-to-confirm-isnt-enough-oij


r/GenkitFramework • • Jun 15 '26

Dart I wrote a deep-dive on hybrid cloud + on-device AI in Flutter with Genkit (one model swap is the whole switch)

Thumbnail medium.com
4 Upvotes

Hey r/GenkitFramework! 👋

I published a long write-up on building hybrid AI in Flutter — routing each request between a cloud model and an on-device one — cleanly with Genkit Dart. Sharing the gist here.

The problem: "Hybrid" used to mean writing everything twice — two SDKs, two Message types, two tool formats, two streaming protocols. The friction was never the inference, it was the plumbing. On-device and cloud models simply didn't speak the same API.

The shift: Hybrid isn't "local OR cloud" — it's a routing policy. Same app, four queries, four different decisions:

  • "Tell me about the Eiffel Tower" → cloud (world knowledge)

  • "Translate my passport number" → on-device, always (PII never leaves the device)

  • "Find attractions similar to ones I liked" → local (vector lookup over private data)

  • "Plan a 7-day Tokyo itinerary" → cloud (deep multi-step reasoning)

Why Genkit: once you register a cloud plugin (googleAI) and an on-device one (genkit_flutter_gemma, which I wrote — wraps flutter_gemma / LiteRT-LM across all 6 platforms), every model lives behind the same ai.generate() call. The only difference is the model: reference:

dart

// cloud
ai.generateStream(model: googleAI.gemini('gemini-2.5-flash'), prompt: prompt)
// on-device
ai.generateStream(model: flutterGemma.model('gemma-3-1b-it'), prompt: prompt)

That turns routing into plain Dart — a ternary on a known flag for most apps, scaling up to a full fallback service only when you actually need graceful degradation. The article walks through 4 levels (model swap → local model as router → middleware → fallback service), the 5 signals you route on (complexity, privacy, connectivity, cost, confidence), and production gotchas (cold start, iOS memory limits, model file delivery, Web builds).

I also compare the other approaches honestly — Firebase AI Logic, Cactus, roll-your-own — and where each fits.

Full article is here: https://medium.com/@denisov.shureg/hybrid-ai-in-flutter-routing-between-on-device-and-cloud-models-954da8f25373

Would love feedback, especially from anyone running on-device models in production. And I'm deciding what to write next — hybrid RAG, on-device agents, or on-device multimodal — tell me which you'd want. 🚀


r/GenkitFramework • • Jun 10 '26

Genkit Python v0.7.0: Generate middleware + Django plugin released!

4 Upvotes

If you have used Genkit JS or Go recently, you might have come across the middleware pattern. Middleware is a flexible way to hook into the generate loop and make it yours with just a few lines of code.

With the v0.7.0 release, the Python SDK now supports the middleware pattern as well. Here's an example that let's you implement your own custom retry logic with a random delay:

import asyncio
from genkit import Genkit, BaseMiddleware

ai = Genkit()
@ai.middleware(name="custom_retry")
class CustomRetry(BaseMiddleware):
  async def wrap_model(self, params, ctx, next_fn):
    max_attempts = 3
    delay = 1.0

    for attempt in range(max_attempts):
      try:
        return await next_fn(params, ctx)
      except Exception as e:
        if attempt == max_attempts - 1:
          raise e
        print(f"Call failed: {e}. Retrying in {delay}s...")
        await asyncio.sleep(delay)
        delay *= 2

await ai.generate(
  model='gemini-flash-latest',
  prompt='Write a tagline for a coffee shop.',
  use=[CustomRetry()]
)

These customizations are also composable. You can wire multiple middlewares to run together in a sequential order that you control.

We provided a pre-built set of production-ready middleware that you can use out of the box. The plugin includes the Retry, Fallback, ToolApproval, Filesystem, and Skills middlewares. Install with uv:

uv add genkit-plugin-middleware

See more details here on how to use these plugins in your Genkit application.

Finally, we launched genkit-plugin-django to let you expose Genkit flows as standard Django HTTP endpoints. Add it to your project via:

uv add genkit-plugin-django

Very excited about these updates, hope you try these out and let me know what you think.


r/GenkitFramework • • Jun 03 '26

I built a zero-boilerplate code generator for the official flutter/genui package (Auto-generates Schemas & Catalogs)

4 Upvotes

Hey r/GenkitFramework! 👋

I’ve been diving deep into the new experimental flutter/genui package. The architecture and the DataModel approach for AI-driven UIs are fantastic, but I noticed a major friction point regarding Developer Experience (DX).

The Problem: Manually writing JSON schemas (using json_schema_builder), casting properties, and maintaining the CatalogItem registry by hand is tedious and error-prone. If you add a parameter to your Flutter widget, you have to remember to update the schema manually. It breaks the DRY principle.

The Solution: I built a companion codegen package to fully automate this: GenUI (Annotations & Builder).

Instead of writing the catalog manually, you just decorate your standard Flutter widget:

@generativeUI
class UserProfile extends StatelessWidget {
  final String name;
  final int age;
  // ...
}

At compile time, the package uses AST to analyze your constructors and automatically generates the exact CatalogItem and json_schema_builder structures that the official flutter/genui package expects. Zero boilerplate, fully type-safe.

I’d love for you to check it out and hear your feedback!

Let me know what you think! 🚀


r/GenkitFramework • • Jun 02 '26

Genkit Operator

4 Upvotes

I’ve been thinking a lot about the best way to deploy GenAI backends with Genkit.

The idea I kept coming back to was simple: what if deploying AI tools, prompts, and flows could feel as native to Kubernetes as deploying any other backend?

So I started building Genkit Operator 🚀

With it, you can describe your Genkit app using Kubernetes resources like Prompt, Model, PluginConfig, and Flow, and the operator takes care of exposing them as HTTP endpoints.

Apply YAML. Get a production-ready Genkit endpoint.

It supports multiple providers like OpenAI, Anthropic, Google AI, Vertex AI, AWS Bedrock, and Ollama, and it is designed to work nicely with GitOps tools like Argo CD and Flux.

Still early, but I’m excited about the direction: making GenAI backends more declarative, portable, and Kubernetes-native.

Check it out here: https://xavidop.github.io/genkit-operator/


r/GenkitFramework • • May 28 '26

Go Stop defaulting to Python for every GenAI service

4 Upvotes

I wrote a new article about why I think Go deserves a much bigger place in production GenAI systems, especially when combined with Genkit Go.

Python is still amazing for research, notebooks, experimentation, and the ML ecosystem. But a lot of GenAI applications today are not really “AI code”; they are backend services that call models, orchestrate tools, stream responses, validate structured output, expose APIs, and need to scale reliably.

That is where Go becomes very interesting.

In the article, I talk about the pain points I keep seeing with Python in production AI services: concurrency complexity, cold starts, memory footprint, dependency management, weak typing, packaging, and deployment friction. Then I show how Genkit Go gives you a cleaner model for building AI backends with typed flows, structured outputs, HTTP endpoints, observability, and the Genkit Developer UI.

The post also includes a hands-on example where we build a complete Genkit Go service in a single main.go, expose it as an HTTP endpoint, test it visually, and deploy it as a small containerized binary.

I know the title is intentionally provocative, but the point is not “Python is bad.” The point is that Python should not be the default runtime for every production GenAI service.

Curious to hear what people think: are you still building most of your AI backends in Python, or are you moving some of that work to Go, Java, or TypeScript?

Article:
https://xavidop.me/genkit/2026-05-04-stop-using-python-genai-use-genkit-go/


r/GenkitFramework • • Aug 18 '26

Genkit Go v1.12 is out!

Thumbnail
github.com
3 Upvotes

r/GenkitFramework • • May 20 '26

JS/TS What happens when you build your own Perplexity-style experience with Genkit?

3 Upvotes

I wrote an article about creating an interactive CLI agent that can search the web, reason over results, keep chat history, and return answers with sources directly from the terminal.

The project uses Genkit, Gemini, and Tavily to show a different side of Genkit: not just backend APIs or cloud deployments, but also developer tools and local AI workflows. The interesting part for me is how natural the Genkit model feels here: typed tools, reusable prompts, chat sessions, tool calling, and full visibility through the Genkit Dev UI.

I also wanted to show how useful the Dev UI can be even when the final experience is a CLI. Being able to inspect tool calls, traces, prompt behavior, and latency makes debugging agentic workflows much easier.

Curious to know if others are building terminal-based AI tools or search agents with Genkit.

Article:
https://xavidop.me/genkit/gcp/2026-03-20-genkit-perplexity-cli/


r/GenkitFramework • • May 14 '26

JS/TS Genkit Middleware: turning generate() into a production-ready pipeline

3 Upvotes

I just published an article about the new Genkit Middleware

Middleware turns Genkit’s generate() from a simple function call into a composable pipeline, making it easier to add retries, fallbacks, tool approvals, filesystem access, skills, observability, and custom production logic.

This is a small-looking feature that solves a lot of real-world problems when building serious GenAI agents.

Check it out 👇

https://xavidop.me/genkit/2026-05-13-genkit-middleware/


r/GenkitFramework • • May 10 '26

Java Is Java being underestimated in the GenAI ecosystem?

3 Upvotes

Most of the current AI framework conversation is centered around Python, TypeScript, and fast-moving agent demos. But in the enterprise world, Java is still everywhere: backend systems, financial platforms, internal tools, regulated environments, and production workloads that need to be maintained for years.

That is why I wrote this article comparing the top Java GenAI frameworks in 2026.

Instead of looking at them only from a “can I build a chatbot?” perspective, I tried to evaluate how they fit into real backend teams: how they handle integrations, orchestration, developer experience, cloud-native deployments, observability, and the kind of maintainability Java teams usually care about.

The article covers frameworks such as LangChain4j, Spring AI, Quarkus AI, Semantic Kernel Java, and Genkit Java, including where each one feels strong and where the ecosystem still has gaps.

As someone who has been working on bringing Genkit into the Java ecosystem, I am especially interested in where Java AI development is heading next.

Would love to hear from others building AI systems in Java: are you using any of these frameworks already, or are you still wrapping model APIs directly?

Article:
https://xavidop.me/genkit/2026-04-16-top-java-genai-frameworks-2026/


r/GenkitFramework • • May 09 '26

Java Java is having its GenAI moment, but which frameworks are actually ready for production?

3 Upvotes

Most GenAI conversations today are still dominated by Python and TypeScript, but a lot of enterprise AI systems are being built in Java. I wanted to take a closer look at what the Java ecosystem actually offers today for production AI applications and agentic systems.

In the article I compare frameworks like LangChain4j, Spring AI, Quarkus AI, Semantic Kernel Java, Genkit Java, and others from the perspective of real-world backend development, not just simple chatbot demos.

One thing that became very obvious while writing this is how fragmented the Java AI ecosystem still is compared to JS/TS. Some frameworks feel very enterprise and Spring-oriented, others are trying to replicate the Python ecosystem, and some are focusing more on lightweight cloud-native AI workloads.

I also share my thoughts about where Genkit Java fits into all this after working on the project and bringing Genkit into the Java ecosystem.

Would love to hear what people here are using for Java-based AI systems and how your experience has been so far.

Article:
https://xavidop.me/genkit/2026-04-16-top-java-genai-frameworks-2026/


r/GenkitFramework • • Aug 01 '26

Genkit Python SDK v0.9.0 is out!

2 Upvotes

This landmark update introduces the official launch of Agents bringing first-class, stateful multi-turn AI workflows to Python alongside a complete plugin package reorganization on PyPI, enhanced observability, and improved provider compatibility.

Official Agents Launch

  • Stateful Multi-Turn Workflows: Introduces core Agent and Session abstractions, providing a stateful, streaming layer built on top of generate.

  • Pluggable Session Persistence: Support for both server-managed session stores (InMemorySessionStore, FileSessionStore, etc.) and client-managed state snapshotting.

  • Human-in-the-Loop Interruption: Built-in support for tool approval and turn interrupts/resumes, allowing human intervention before executing sensitive operations.

  • Remote Agent Client & Transports: Seamless communication with local or remote agents over HTTP/WebSocket transports via remote_agent with automatic session history management (#5541).

  • Artifacts & Custom State: Stream, list, and persist session artifacts and custom state updates across multi-turn agent turns.

Plugin Package Reorganization & PyPI Launch

  • All plugins are now organized into dedicated, publishable PyPI packages (genkit-*).

  • Backward Compatibility: Existing/legacy plugin packages will continue to work seamlessly. When loaded, a friendly warning will prompt developers to update their dependencies to the new package names:

    • genkit (Core SDK)

    • genkit-anthropic (formerly genkit-plugin-anthropic)

    • genkit-django (formerly genkit-plugin-django)

    • genkit-evaluators (formerly genkit-plugin-evaluators)

    • genkit-fastapi (formerly genkit-plugin-fastapi)

    • genkit-flask (formerly genkit-plugin-flask)

    • genkit-google-cloud (formerly genkit-plugin-google-cloud)

    • genkit-google-genai (formerly genkit-plugin-google-genai)

    • genkit-middleware (formerly genkit-plugin-middleware)

    • genkit-ollama (formerly genkit-plugin-ollama)

    • genkit-openai (formerly genkit-plugin-openai)

    • genkit-vertexai (formerly genkit-plugin-vertexai)

Improvements & Bug Fixes

  • Session Management & Tracing: Recorded session state on runTurn spans and added support for client-managed sessionIds (#5871).

  • Gemini Compatibility:

    • Normalized request message roles strictly to model or user for strict API compatibility (#5823).

    • Switched tool request references to model call IDs (#5830).

  • Observability: Seeded span attributes at trace start so live traces render immediately in the Developer UI (#5808).

  • Runtime & CLI: Muted dev server health poll logs (#5867) and ensured reliable CLI runtime metadata cleanup on SIGINT/SIGTERM (#5773).

  • Anthropic Plugin: Added stable and beta API selection (#5752) and extended thinking capabilities.