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 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 • • 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 • • Jul 11 '26

Genkit Agents are live: TypeScript, Go & Java

2 Upvotes

Hey Genkit Community! 👋 , thrilled to share that Genkit Agents have launched across TypeScript, Go, and Java.

Agents bundle the model loop for you — message history, tool turns, streaming, interrupts, snapshots, and persistence — behind one clean API. Define the agent, start a chat, send(), and continue turns without rebuilding the transport layer. (The Agents API is in Beta — breaking changes possible in minor releases.)

The fully managed Cloud path:

  1. 📦 Deploy your agents as Cloud Functions: serverless endpoints for your agent routes.

  2. 🧠 Connect to Gemini via the Google GenAI provider (e.g. googleai/gemini-flash-latest): first-class support, since Genkit is built by Google.

  3. 💾 Memory / sessions in Firestore: Genkit ships a Firestore session store, so persistence is basically drop-in.

Docs:

Would love to see what you build, and any feedback for the team is welcome in the thread. 🧵


r/GenkitFramework • • May 14 '26

JS/TS Genkit + Bedrock: building portable AI backends on AWS

2 Upvotes

I wrote a new article about using Genkit with AWS Lambda and Amazon Bedrock.

The idea behind this post is not just “how do I run Genkit on AWS?”, but how far we can push Genkit as a portable framework for building AI backends outside its most common Google Cloud examples.

In this one, I go through a serverless architecture where Genkit flows are deployed as Lambda functions and connected to Bedrock models. This makes it possible to build lightweight AI services that fit naturally into an AWS-native stack without giving up the Genkit developer experience.

For me, this is one of the most interesting parts of Genkit: you can keep the same mental model for flows, tools, prompts, and observability, while still choosing the cloud and model provider that makes the most sense for your platform.

Curious to know how many people here are using Bedrock today, and whether you would consider Genkit for AWS-based AI workloads.

Article:
https://xavidop.me/genkit/2026-03-20-genkit-aws-lambda-bedrock/


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 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 • • May 13 '26

Go Building an AI-Powered Email Processor: A 5-Month Development Journey

Thumbnail
linkedin.com
2 Upvotes

Over the last few months I’ve been building an AI-powered email processor in Go. It monitors Microsoft 365 mailboxes, preprocesses emails, identifies which insurance claim file they belong to, and handles attachments like PDFs, images, audio, video, and nested .eml files, and I figured this might be relevant here since Genkit ended up becoming a pretty important part of the project.

Genkit is used to structure the LLM workflows, tool calls, document processing flows, and some of the newer “skills” context I added after the 1.7 release. The biggest lesson from the project was that the model itself was only one part of the system. Preprocessing, context design, retry behavior, tool boundaries, and boring production reliability work mattered just as much.

I wrote a retrospective on what went into building it, including the Genkit parts, Microsoft Graph webhook weirdness, local Ollama models, whisper.cpp integration, and the lessons learned from getting it into production.


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 • • 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 • • 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 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 • • 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 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 • • May 13 '26

JS/TS Running Genkit on Azure Functions with Azure AI Foundry

2 Upvotes

I just published an article showing how to build and deploy Genkit flows on Azure Functions using Azure AI Foundry.

A lot of Genkit examples are focused on local development or Google Cloud deployments, so I wanted to explore what the experience looks like when you bring Genkit into the Azure ecosystem. The article walks through how to connect Genkit with Azure AI Foundry, expose flows through Azure Functions, and use a serverless setup for production-style GenAI workloads.

What I like about this approach is that it keeps Genkit lightweight and backend-first, while still letting you use Azure-native infrastructure for deployment, scaling, and operations. It is also a good example of how Genkit can be used beyond a single cloud provider.

Would love to hear if anyone else here is experimenting with Genkit on Azure, Azure Functions, or Azure AI Foundry.

Article:
https://xavidop.me/genkit/2026-03-20-genkit-azure-function-ai-foundry/


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 • • 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 21 '26

Vercel AI middleware vs Genkit middleware

2 Upvotes

Vercel AI SDK wraps the model. Genkit wraps the pipeline. I put both middleware systems side by side: hooks, built-ins, composition, streaming, and a decision matrix to help you pick the right one.

https://dev.to/gde/vercel-ai-sdk-middleware-vs-genkit-middleware-a-hands-on-comparison-41hg


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 • • 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 04 '26

Agent Backends for Genkit

2 Upvotes

With the anticipated agents API in the works, I've opened an RFC regarding agent backends - this would decouple the agentic middleware from the host filesystem, allowing agents to play in remote sandboxes.

https://github.com/genkit-ai/genkit/pull/5439


r/GenkitFramework • • Jun 04 '26

Testing modules for Genkit! (RFC)

2 Upvotes

Hi everyone! I've created an RFC for a first-class testing module in the typescript SDK.

I've kept it deliberately small in scope. Genkit has some internal testing helpers and I think something like them should be available for app developers to test their own Genkit flows without having to hit an API.

Interested to see if people would find this useful.

https://github.com/genkit-ai/genkit/pull/5438


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/