Agent Frameworks & Libraries
Open-source frameworks and SDKs for building AI-powered applications on the JVM — from full agent platforms to Model Context Protocol implementations.
Spring AI
The Spring ecosystem's official AI framework. Portable abstractions across 20+ model providers, tool calling, RAG, chat memory, vector stores, and MCP support. Built by the Spring team at Broadcom.
LangChain4j
The most popular Java LLM library. Unified API across 20+ LLM providers and 20+ embedding stores. Three levels of abstraction from low-level prompts to high-level AI Services. Supports RAG, tool calling, MCP, and agents.
Embabel
Created by Rod Johnson (Spring Framework creator). JVM agent framework using Goal-Oriented Action Planning (GOAP) for dynamic replanning. Strongly typed, Spring-integrated, MCP support. Written in Kotlin with full Java interop.
Google ADK for Java
Google's Agent Development Kit — code-first Java toolkit for building, evaluating, and deploying AI agents. Supports Gemini natively plus third-party models via LangChain4j integration. A2A protocol for agent-to-agent communication.
Quarkus LangChain4j
Enterprise-grade Quarkus extension for LangChain4j. Native compilation with GraalVM, built-in observability (metrics, tracing, auditing), and Dev UI tooling. Maintained by Red Hat & IBM.
Helidon LangChain4j
Oracle's Helidon framework integration with LangChain4j. Declarative AI Services via Helidon Inject, build-time code generation for GraalVM native images, streaming chat over Java Streams, guardrails, built-in metrics, and agentic support (workflows and dynamic agents). Runs on virtual threads.
Helidon MCP
Helidon's Model Context Protocol server and client implementation. Declarative and imperative APIs for building MCP servers with tools, resources, and prompts. Streamable HTTP and SSE transports, virtual threads, build-time processing. From Oracle's Helidon team.
Micronaut MCP
Official Micronaut module for building Model Context Protocol servers and clients. STDIO and Streamable HTTP transports, annotation and factory-based tools/prompts/resources, a LangChain4j-backed client option, and GraalVM native image support. Maintained by the Micronaut project team.
Micronaut LangChain4j
Official Micronaut integration for LangChain4j. Compile-time-generated AI services with modules for OpenAI, Anthropic, Azure, Bedrock, Google AI, and Mistral, plus embedding stores for PostgreSQL, Redis, MongoDB, Elasticsearch, Neo4j, Chroma, and Qdrant. Version 2.2.0 adds agentic support, Chroma embedding stores, and guardrails resolved from Micronaut beans.
LangChain4j-CDI
CDI extension for LangChain4j (part of the LangChain4j project) that brings AI services to Jakarta EE and MicroProfile applications. Inject AI services as CDI beans with @RegisterAIService, configure via MicroProfile Config, and add resilience with Fault Tolerance. Supports Quarkus, Helidon, WildFly, Payara, GlassFish, Liberty, and any CDI-capable runtime.
LangGraph4j
Build stateful, multi-agent applications with cyclical graphs. Inspired by Python's LangGraph, works with both LangChain4j and Spring AI. Persistent checkpoints, deep agent architectures, and a Studio web UI.
Akka Agents
Agentic AI platform built on Akka's actor model for distributed, resilient systems. Declarative Effects API for building goal-directed agents with durable memory, multi-agent orchestration, and automatic scaling. Task-based autonomous agents with pause/resume/terminate lifecycle control and task result subscriptions, alongside request-based agents. MCP and A2A protocol support, pluggable LLM providers, runtime prompt updates, and agents auto-exposed as HTTP, gRPC, or MCP endpoints. Java and Scala SDKs.
Koog (JetBrains)
Kotlin-native agent framework from JetBrains. Type-safe DSL, multiplatform (JVM, JS, WasmJS, Android, iOS), A2A protocol support, fault tolerance with persistence, and multi-LLM support.
Semantic Kernel (Java)
Microsoft's AI orchestration SDK with first-class Java support. Provides prompt chaining, planning, memory, and agent framework abstractions with deep Azure integration.
JamJet
Production-grade agent runtime with native Java SDK. Rust core (Tokio) for performance, graph-based durable workflow orchestration with event-sourced state, automatic crash recovery, audit trails, and first-class human-in-the-loop. Native MCP client/server and A2A protocol support. Java SDK uses records, virtual threads, and fluent builder API. Apache 2.0.
Spring AI AgentCore SDK
Spring Boot integrations for Amazon Bedrock AgentCore. Auto-configures /invocations and /ping endpoints, SSE streaming, short- and long-term memory, browser automation via Playwright, and a secure code interpreter. Deploy to AgentCore Runtime (managed, scales to zero) or standalone on EKS/ECS.
MCP Java SDK
The official Java SDK for Model Context Protocol servers and clients. Maintained by the Spring AI team. Sync/async, STDIO/Streamable HTTP transports (SSE deprecated as of 2.0), OAuth support via Spring integration. Reached v2.0.0 GA in June 2026 with spec-accurate JSON Schema 2020-12 validation and enforced required fields.
Anthropic Java SDK
Official Java SDK for the Claude Messages API. Streaming, retries, structured outputs, extended thinking, code execution, and files API. Build Java apps powered by Claude.
GitHub Copilot SDK for Java
Official Java SDK for embedding the GitHub Copilot agentic engine directly into Java applications. Uses the same agentic harness that powers the Copilot CLI — exposes planning, tool calling, file editing, and MCP integration via a simple Java API. Currently in technical preview.
Graal Script Agent
Early-preview Java library for adding prompt-authored extensions to Java applications. Developers define where an application can be extended; users prompt for the behavior they need. It produces reusable JavaScript or Python extensions that execute locally in a sandbox without another model call.
Tracy (JetBrains)
AI tracing library for Kotlin and Java. Captures structured traces from LLM interactions — messages, cost, token usage, and execution time. Implements OpenTelemetry Generative AI Semantic Conventions with exports to Langfuse, Weights & Biases, and more.
Docling Java
Official Java client for Docling Serve — invoke document conversion, table detection, formula recognition, reading order analysis, OCR, and more from Java via the Docling Serve backend.
OmniHai
Unified Java AI utility library for Jakarta EE and MicroProfile. Single API across 10 providers with zero external runtime dependencies — just java.net.http.HttpClient. Chat, streaming, structured outputs, web search, translation, and moderation in a lightweight JAR.
ACP Langchain4j bridge
An ACP client bridging the official Kotlin ACP sdk to LangChain4j and LangGraph4j.
A2A Java SDK
The official Java SDK for Agent-2-Agent Protocol (A2A) servers and clients. Reference implementation based on Quarkus. Reached 1.0 GA in June 2026 with full JSON-RPC/gRPC/REST transport support, OpenTelemetry integration, and a cross-SDK interop test kit; 1.1.0 added a TaskAuthorizationProvider SPI for per-user task authorization; 1.2.0 (Aug 2026) adds programmatic auth wiring and a TaskStreamLifecycleHook, with breaking changes to TaskState naming and cross-module package resolution.
A2A Java SDK for Jakarta Servers
Integration of the A2A Java SDK for use in Jakarta EE servers (WildFly, Tomcat, Jetty, OpenLiberty, and others).
WildFly AI Feature Pack
A feature pack for WildFly, providing seamless LangChain4j-CDI integration and exposing Jakarta EE code as MCP tools via MCP_JAVA Annotations.
MCP_JAVA Annotations
A framework-agnostic Java library providing core annotations and APIs for implementing Model Context Protocol (MCP) servers and clients. Used by WildFly AI Feature Pack and LangChain4j-CDI. Compatible with OpenLiberty, Quarkus, and other Java frameworks.
Atmosphere
A portable layer across Java AI runtimes. Write @Agent once against a unified API (tool calling, memory, streaming, structured output); swap the runtime — Spring AI, LangChain4j, Google ADK, Embabel, Koog, or built-in OpenAI — by changing one dependency. @Coordinator orchestrates multi-agent fleets with parallel, sequential, and conditional routing. Served over transports (WebTransport/HTTP3, WebSocket, SSE, long-polling, gRPC) and protocols (MCP, A2A, AG-UI). Built by Async-IO.
Spring AI Agent Utils
Community library from the Spring AI team that brings Claude Code-inspired agentic primitives to Spring AI applications — file operations, shell execution, web fetch, task/subagent orchestration, auto-memory, and a portable Agent Skills implementation. Built on Spring AI 2.0's agentic foundation.
Spring AI A2A
Spring Boot integration for building Agent2Agent (A2A) protocol servers. Auto-configured JSON-RPC endpoints and task lifecycle handling wired to Spring AI's ChatClient, with full @Tool support and multi-agent orchestration. Complements the A2A Java SDK for Spring applications.
Spring AI Session
Event-sourced conversation memory for Spring AI. Structured events with identity, timestamps, and session ownership; turn-aware compaction that trims history on turn boundaries; multi-agent branch isolation; keyword search over history; and pluggable in-memory or JDBC repositories via an SPI.
Spring AI Playground
Cross-platform desktop app from the Spring AI Community that acts as a local execution layer for AI agent tools. Build, test, and publish MCP tools with a deny-first sandbox, per-tool risk levels, and human-in-the-loop approval for sensitive operations, plus observability dashboards for tokens, cost, traces, and tool execution.
Jakarta Agentic AI
Eclipse Foundation specification proposal defining vendor-neutral APIs for building, deploying, and running AI agents on Jakarta EE runtimes. Annotation-based programming model (@Agent, @Trigger, @Decision, @Action, @Outcome) built on CDI, REST, and Config — pluggable with existing frameworks like LangChain4j and Spring AI rather than replacing them. Proposed by Payara and Reza Rahman, backed by Oracle, Fujitsu, and OmniFish; version 1.0 under active development.
AgentScope Java
Alibaba's JVM-native framework for production-ready, distributed agents. Event-streaming architecture, permission-gated tool execution, sandboxed tool execution (local, Docker, or Kubernetes), and distributed session/memory backed by Redis, MySQL, or PostgreSQL. Reached v2.0.0 GA in July 2026.
JVector
DataStax's pure-Java embedded vector search engine combining DiskANN and HNSW graph designs for approximate nearest-neighbor search, SIMD-accelerated via the Java Vector API. Supports indexes larger than available memory via two-pass compressed search. Powers Apache Cassandra and AstraDB; has an official LangChain4j embedding-store integration.
Milvus Java SDK
Official Java client for Milvus, one of the most widely used open-source vector databases. Type-safe API for collection management, ANN and hybrid search, and bulk import, with modular packaging (core plus an optional BulkWriter module). Commonly paired with LangChain4j and Spring AI vector-store integrations in Java RAG stacks.
ClawRunr
Open-source personal AI agent runtime built on Spring Boot, Spring AI, and JobRunr — runs entirely on your own hardware. Schedules and executes background tasks, browses the web, and manages work via human-readable Markdown files, with multi-channel support (chat UI, Telegram, Discord) and pluggable OpenAI, Anthropic, or Ollama providers. Built by the JobRunr team; started as a demo and grew into a community project.
MCP Toolbox Java SDK
Official Google Java client library for MCP Toolbox. Lets Java agents (Spring Boot, Quarkus, Jakarta EE) discover and invoke Toolbox-defined tools — database queries, API calls — via a type-safe, async-first CompletableFuture API with Google Cloud ADC authentication. Apache 2.0; feature set is still catching up to the Python, JS, and Go SDKs.
Tools4AI
Pure-Java agentic framework that converts natural-language prompts into executable actions — Java method calls, REST endpoints, shell commands, or Swagger API calls — with multi-provider support across Gemini, OpenAI, Anthropic, and LocalAI. No Spring dependency required. MIT licensed, published to Maven Central.
EclipseStore
Eclipse Foundation's Java-native persistence engine — stores and loads full object graphs with microsecond response times, no JPA/ORM overhead. Version 4 integrates JVector into its GigaMap indexing, turning EclipseStore into an embedded, pure-Java vector database: HNSW similarity search, on-disk indexing for datasets larger than memory, and Product Quantization to shrink embedding footprints by up to 90%.
OpenAI Java SDK
Official Java client library for the OpenAI API, maintained by OpenAI. Written in Kotlin with full Java interop. Typed access to Chat Completions and the Responses API, streaming, structured outputs, function calling, and asynchronous execution via CompletableFuture.
Google Gen AI Java SDK
Google's official Java SDK unifying access to the Gemini Developer API and Vertex AI. Supports Gemini text/chat, Imagen image generation, Veo video generation, embeddings, token counting, and automatic function calling. Distinct from Google ADK for Java, which is an agent-orchestration framework built on top of it.
IBM watsonx.ai Java SDK
IBM's official Java SDK for the watsonx.ai enterprise AI platform. Chat completions, streaming, tool calling, embeddings, text classification/extraction/detection, reranking, and time-series forecasting, for both IBM Cloud and on-premises deployments. Integrates with LangChain4j, Quarkus, and Apache Camel.
Spring AI — watsonx.ai
Official Spring AI integration for IBM watsonx.ai. Spring Boot auto-configuration for chat (IBM Granite, Meta Llama, Mistral AI), embeddings, content moderation (HAP, PII, Granite Guardian), and document reranking via Spring AI's portable abstractions. Supports streaming, function calling, and reactive programming with WebFlux.
SAP AI SDK for Java
SAP's official Java SDK for integrating generative AI into enterprise applications via SAP AI Core and the Generative AI Hub. Orchestration service integration, prompt templating, grounding, data masking, content filtering, and Spring AI compatibility.
Tiberius
Java security and safety testing framework for Java LLM-enriched applications, integrating with JUnit 5 and Spring Boot so adversarial testing lives in the standard test suite. 200+ attack probes across the OWASP LLM Top 10, probabilistic testing (via PUnit) for non-deterministic LLM outputs, fixture-based regression testing, bias testing, model fingerprinting, and LangChain4j guardrail validation. Apache 2.0.
Ollama4j
Java client library for running models via a local Ollama server. Chat, streaming, tool/function calling (including MCP tools), vision-model image inputs, embeddings, and model management, with Prometheus metrics support. Requires Java 17+, published to Maven Central.
Cohere Java SDK
Official Java SDK for the Cohere API, generated and maintained by Cohere. Chat, embeddings, reranking, and classification endpoints, published to Maven Central.
kyo-ai
AI module for Kyo, the Scala 3 algebraic-effects toolkit. Makes an LLM call a typed, composable value — schema derived from your result type, tool-call loop and conversation threading handled automatically, streaming and persistent actor-backed agents included. Multi-provider (OpenAI-compatible, Anthropic). As of Kyo 1.0.0-RC5 (July 2026), kyo-ai moved into the main Kyo monorepo alongside a new kyo-mcp module for MCP server/client support. Apache 2.0.
zio-bedrock-converse
Typed Scala 3 access to the Amazon Bedrock Converse API, built on ZIO and ZIO HTTP. Three abstraction levels — low-level wire control, single-turn requests, and multi-turn agentic loops with automatic tool dispatching — with tool schemas derived from Scala types and streaming text responses. Typed end-to-end with no DynamicValue in the public API. Apache 2.0.
zio-http-mcp
MCP server and client library for Scala 3, ZIO, and ZIO HTTP. Typed tool inputs and outputs via ZIO Schema, resources and prompt templates, OAuth 2.1 authorization, stateful or stateless HTTP transports, and server-initiated messaging (sampling, elicitation) over SSE. Supports the 2025-11-25 and 2026-07-28 MCP protocol revisions with automatic negotiation.
Tachyon
Java 21+ runtime for building high-performance MCP servers — write blocking handler code and virtual threads run it off the Netty event loop, no reactive boilerplate. Stateless by default with optional sessions, native Netty transports (io_uring/epoll/kqueue), a Kotlin DSL, and full MCP 2025-11-25 and 2026-07-28 support verified against the official conformance tests. Apache 2.0, currently in beta.
Solon-AI
Full-scenario Java AI application module of the Solon framework ecosystem — LLM chat and tool/skill calling, RAG knowledge bases, MCP client/server support, and ReAct/multi-agent Team orchestration. Embeddable in Spring Boot, jFinal, Vert.x, and Quarkus; supports Java 8–25.
AWS SDK for Java v2 — Bedrock
Official AWS SDK for Java v2 modules (bedrockruntime, bedrockagentruntime) for invoking Amazon Bedrock foundation models and Bedrock Agents from Java. Part of the actively-released aws-sdk-java-v2 monorepo, joining the Google Gen AI, IBM watsonx.ai, and SAP AI Java SDKs already listed here.
Qdrant Java Client
Official Java client for the Qdrant vector database — collection management, vector upsert, and similarity search over gRPC, with sync and async (ListenableFuture) support.
Weaviate Java Client
Official Java client for the Weaviate vector database. The v6 line is a from-scratch rewrite for Weaviate ≥1.32, replacing the deprecated v5 client, with a "Tucked Builder" API for data ingestion, semantic search, filtering, and collection management.
Pinecone Java Client
Official Java client for the Pinecone vector database. Covers index management (serverless, pod-based, BYOC, sparse indexes), collection operations, vector upsert/query/fetch/update/delete, namespace management, and Pinecone's hosted inference API (embeddings, reranking, model listing). Joins the site's other official vector-database clients for Qdrant, Weaviate, and Milvus.
Testcontainers Ollama Module
Official Testcontainers-for-Java module for spinning up disposable Ollama containers in integration tests — pull models and commit custom images for reuse. Commonly paired with Spring AI, LangChain4j, and Quarkus LangChain4j to test local-LLM code paths.
Camel LangChain4j Components
Official Apache Camel components that let Camel routes call any LangChain4j-supported LLM. The chat component (since Camel 4.5) covers single, prompted, and multi-turn LLM calls with RAG enrichment; the agent component (since Camel 4.14) adds stateful/stateless AI agents that can invoke Camel routes as tools plus MCP client integration. Producer-only endpoints (langchain4j-chat:id, langchain4j-agent:id) fit naturally into existing integration pipelines. Camel 4.22 generalized tool exposure beyond LangChain4j: camel-ai-tool defines a route-as-tool once for use with LangChain4j, Spring AI, or OpenAI, and camel-mcp-server exposes tagged routes directly as MCP tools.
Google ADK for Kotlin
Google's official Kotlin port of the Agent Development Kit — code-first orchestration of tools, agents, and multi-agent hierarchies in Kotlin, with an included dev UI for testing and evaluation. A companion Android flavor adds on-device agent support (Gemini Nano) with cloud fallback.
LLM4S
Scala 3 framework for building LLM applications — multi-provider support (OpenAI, Anthropic, Azure OpenAI, Gemini, DeepSeek, Cohere, Mistral, OpenRouter, Ollama), an agent framework with tool calling via ScalaMeta, RAG/vector stores, multimodal input, and OpenTelemetry/Langfuse tracing. Broader in scope than the site's other Scala entries — closer to a "LangChain4j for Scala." Pre-1.0, MIT licensed, active development with weekly community dev-hours.
Agents-Flex
Lightweight Java AI application framework positioned as a Spring AI counterpart — unified abstractions for LLM calls, tool calling, agents (ReAct, routing, sub-agents), RAG with vector stores, MCP, a Skills system, and Text2SQL. Runs on plain Java, Spring Boot, or other JVM stacks (Java 8+). Apache 2.0, with frequent releases.
Spring AI Alibaba
Alibaba Cloud's production-ready framework for agentic, workflow, and multi-agent Java applications, built on top of Spring AI. Graph-based orchestration (SequentialAgent, ParallelAgent, RoutingAgent, LoopAgent), multimodal ReactAgent support, MCP integration, and a built-in Admin observability/eval console. JDK 17+, Apache 2.0.
BoxLang AI
Unified AI platform for the JVM from Ortus Solutions (makers of BoxLang and ColdBox). One API across 15+ providers, plus multi-agent orchestration with parent-child hierarchies, an Agent Skills system implementing Anthropic's open standard, MCP support (consuming and serving), 20+ memory types with vector RAG, and a composable middleware pipeline. Reached v3.0 in 2026. Apache 2.0.
Java with Code Assistants
Technologies that supercharge Java development when paired with AI code assistants — from MCP servers that give agents live Javadoc access, to reusable skill packages and IDE integrations.
AI-Git-Bot
Self-hosted AI workflow automation platform for Git repositories. Automates pull request reviews, test generation, issue management and documentation synchronization with the support of multiple AI backends. Pure Java application with a Spring-Boot based architecture.
Javadocs.dev MCP Server
Gives AI assistants live access to Java, Kotlin, and Scala library documentation from Maven Central. Six tools including latest-version lookup, Javadoc symbol browsing, and source file retrieval. Connect any MCP client via Streamable HTTP.
JetBrains AI
AI-powered coding assistance built into IntelliJ IDEA and all JetBrains IDEs. Context-aware code completion, next-edit suggestions, and an agent-mode chat for refactoring, test generation, and complex tasks. Deep understanding of Java, Kotlin, and Scala project conventions. Supports cloud LLMs (Gemini, OpenAI, Anthropic) plus bring-your-own-key.
SkillsJars
A packaging format and registry for distributing reusable AI agent skills as Maven/Gradle JARs. Skills are Markdown files (SKILL.md) under META-INF/skills/ that teach AI agents domain-specific patterns. Discover and load skills on demand in Claude Code, Kiro, and Spring AI apps.
jvm-skills
Curated directory of AI coding skills from JVM ecosystem engineers. Opinionated best-practice guides that AI tools (Claude Code, Cursor, Copilot) use as context — covering Spring Boot, jOOQ, Testcontainers, Docker, and more. Only lists skills that teach AI something it wouldn't know on its own.
Awesome GitHub Copilot
Awesome Copilot Skills is a curated registry of reusable AI agent skills that developers can plug into agents, providing ready-made capabilities, prompts, and workflows. It helps Java AI developers quickly extend agent functionality without building everything from scratch.
jOOQ MCP Server
Gives AI assistants live access to jOOQ documentation and examples. Connect any MCP client via Streamable HTTP.
MCP ServerVaadin MCP Server
Gives AI assistants live access to Vaadin documentation and examples. Connect any MCP client via Streamable HTTP.
Quarkus Agent MCP
Official standalone MCP server from the Quarkus team that teaches AI coding agents to work with Quarkus applications — scaffolding new projects, controlling the app lifecycle, proxying Dev MCP tools, and searching Quarkus documentation. Runs as a separate process that survives app crashes, so agents can read logs and fix code after failures. Works with Claude Code, GitHub Copilot, Cursor, and JetBrains AI.
Open Liberty MCP Server
Built-in Open Liberty runtime feature (mcpServer-1.0) that exposes Jakarta EE and CDI business logic as MCP tools for agentic AI workflows — role-based authorization, dynamic tool registration, and streamable transport. Actively developed through 2026 beta releases from IBM's Open Liberty team.
Maven Tools MCP
Gives AI agents dependency intelligence from Maven Central — version lookup, upgrade comparisons, CVE and license health signals, and POM-aware resolution across Maven, Gradle, SBT, and Mill projects.
JVM Pulse
GitHub Copilot canvas extension that profiles a Java project's garbage collection and JFR telemetry — detects the build tool and JDK, runs a representative workload, and analyzes it with Microsoft's GCToolkit and the JDK jfr CLI. Surfaces throughput, pause times, heap usage, and allocation hot spots in an interactive dashboard, with an "Analyze with AI" hand-off into Copilot for tuning recommendations. Created by Bruno Borges. MIT license.
IntelliJ IDEA MCP Server
IntelliJ IDEA's built-in Model Context Protocol server, bundled and enabled by default since version 2025.2. Exposes over 100 IDE tools — code analysis, refactoring, debugging, run configurations, database operations — to external MCP clients like Claude Code, Claude Desktop, Cursor, and VS Code. Distinct from the JetBrains AI Assistant plugin above.
Apache Camel MCP Server
Official MCP server shipped with Apache Camel 4.18 (camel-jbang-mcp). Exposes the live Camel and Kamelet catalogs, endpoint-URI validation, route understanding, and security analysis as 16 tools for AI coding assistants. Built on Quarkus, runs via JBang, supports STDIO and HTTP/SSE transports.
Micronaut Fun MCP Server
Official MCP server from the Micronaut project team giving AI assistants search access to Micronaut documentation and Guides via OpenSearch. Confirmed integrations for Claude Code, Claude Desktop, VS Code, cline, and IntelliJ IDEA.
Develocity MCP Servers
Two official MCP servers from Gradle Inc.'s Develocity platform — one for per-build data (exceptions, stack traces, test outcomes, cache performance) to investigate failures, and an Analytics server for org-wide queries like flaky-test trends and cache effectiveness. Covers Gradle, Maven, sbt, and Bazel builds.
AssistAI (Eclipse IDE MCP Server)
Community Eclipse IDE plugin that exposes the Eclipse workspace as an MCP server — code analysis, refactoring, build/debug control, and Git operations via EGit — so external AI agents edit through Eclipse's JDT APIs instead of the raw filesystem, keeping incremental compilation and error highlighting in sync. Also bundles an inline AI chat view. MIT licensed.
SonarQube MCP Server
Official MCP server from SonarSource exposing SonarQube Cloud/Server code-quality and security analysis to AI coding agents — issue management, security hotspots, quality gates, coverage, and dependency risk across 50+ tools. Distributed as a Docker image.
TDA (Thread Dump Analyzer)
JVM diagnostics tool for analyzing thread dumps and heap data — deadlocks, bottlenecks, virtual-thread pinning — across JDK 1.4–21+. Usable as a standalone Swing GUI, a JConsole/VisualVM plugin, or a headless MCP server for AI tools like Claude and Cursor.
JAFAR
Fast, modern Java Flight Recorder (JFR) parser for the JVM with typed and untyped parsing APIs, heap-dump analysis, and an interactive analysis shell. Its jfr-mcp module exposes JFR analysis as MCP tools, letting AI agents like Claude directly investigate JVM performance recordings. Apache 2.0, early-stage but active.
MCP JDWP Java
MCP server giving AI agents full debugger control over running Java applications via JDWP/JDI — inspect locals, fields, threads, and object graphs; set conditional, deferred, and chained breakpoints; evaluate expressions in suspended frames; and trace execution with non-intrusive logpoints and field watchpoints, all without restarting the JVM. Runs entirely locally over STDIO. Built on Spring Boot and Spring AI MCP. MIT licensed.
SolonCode
Open-source, provider-agnostic AI coding agent built on the Solon-AI framework, targeting Java 8–26 runtimes. CLI, web, and desktop-IDE interfaces with auto-edit, approval-based execution, and planning agent modes — an open alternative to Claude Code.
Junie
JetBrains' autonomous coding agent — plans and executes multi-step edits, runs tests and the debugger, and opens PRs. Reached GA in June 2026 with a standalone bring-your-own-key CLI (Anthropic, OpenAI, Google, xAI, OpenRouter, Copilot) alongside its JetBrains IDE integration. Distinct from the general-purpose JetBrains AI Assistant above.
Inference & Training
Run models, train classifiers, and do ML inference directly on the JVM — no Python required.
Deliverance
Deliverance is a Java inference engine capable of generating text, tokenizing input, computing embeddings, and more. Can be used as embedded library inside your Java application or as an HTTP server /chat/completion). Deliverance also provides chat and Rag Chat through vibrant-maven-plugin allowing you to chat with your code!
Jlama
⚠️ No longer actively maintained. Modern LLM inference engine written in pure Java. Runs Llama, Gemma, Mistral, and more locally on CPU. Uses Java's Vector API (Project Panama) for SIMD-accelerated matrix math. Supports SafeTensors format, quantized models, and distributed inference.
Deep Java Library (DJL)
AWS's high-level, engine-agnostic deep learning framework. Supports PyTorch, TensorFlow, ONNX Runtime, and XGBoost backends. DJLServing provides high-performance model serving.
ONNX Runtime Java
Run transformer and classical ML models directly on the JVM. Hardware acceleration via CUDA, DirectML, CoreML, and more. Enables deploying scikit-learn, PyTorch, and HuggingFace models as ONNX in Java without Python at inference time.
Tribuo
Oracle Labs' ML library for classification, regression, clustering, and anomaly detection. Strong typing, provenance tracking for reproducibility, and integrations with XGBoost, ONNX Runtime, TensorFlow, and LibSVM.
GPULlama3.java
Java-native LLM inference with automatic GPU acceleration via TornadoVM. Supports Llama 3, Mistral, Qwen, Phi-3, and IBM Granite models in GGUF format. TornadoVM translates Java bytecode to GPU kernels (OpenCL, PTX, SPIR-V). Reached 1.0.0 in July 2026 and is published to Maven Central as io.github.beehive-lab:gpu-llama3 with auto-activating JDK 21 and JDK 25 builds. From the University of Manchester's Beehive Lab.
TornadoVM
GPU programming framework for Java — JIT-compiles Java bytecode into CUDA, OpenCL, and Apple Metal at runtime, running on GPUs and multi-core CPUs. Powers GPULlama3.java's GPU acceleration. v5.2.0 added AI-focused kernels: native FP8 conversion, FP8/BF16 tensor-core matrix multiply, cuBLAS/CUTLASS-compatible BFloat16 arrays, and batched FP16 GEMM. From the University of Manchester's Beehive Lab.
TensorFlow Java
Java bindings for TensorFlow, maintained by the TensorFlow JVM SIG. Train and deploy TF models entirely in Java. Available as an optional Tribuo integration. Suitable for teams that want to stay within the JVM ecosystem while using TensorFlow's model formats.
Eclipse Deeplearning4j (DL4J)
Long-standing JVM deep-learning suite — DL4J for model building, ND4J for linear algebra, SameDiff for automatic differentiation, and DataVec for ETL. GPU/CPU acceleration and distributed training via Spark, plus model import from Keras, TensorFlow, and ONNX/PyTorch. Maintained by Konduit under the Eclipse Foundation.
Apache OpenNLP
Apache's Java-native NLP toolkit — tokenization, part-of-speech tagging, named entity recognition, chunking, parsing, and language detection, with pluggable MaxEnt, Perceptron, Naive Bayes, and SVM classifiers. Actively maintained, with a Java 21-targeted 3.0 branch in progress.
People to Follow
Key voices at the intersection of Java and AI.
Eric Deandrea
Java ChampionDocling Java project lead, contributor to LangChain4j, Sr. Principal Software Engineer at IBM
FAQ
Frequently asked questions about AI development on the JVM.
What is the best Java framework for building AI agents?
The most popular choices are Spring AI and LangChain4j. Spring AI is ideal if you’re already in the Spring ecosystem, offering portable abstractions across 20+ model providers. LangChain4j provides a standalone library with three levels of abstraction, from low-level prompts to high-level AI Services. Other options include Google ADK for Java, Embabel, and Akka Agents — each with different strengths for specific use cases.
Can Java run LLMs locally?
Yes. Projects like Jlama and GPULlama3.java run Llama, Mistral, and other models directly on the JVM. Jlama uses Java’s Vector API for SIMD-accelerated inference on CPU, while GPULlama3.java leverages TornadoVM for GPU acceleration. For production deployments, ONNX Runtime Java supports hardware-accelerated inference across CUDA, DirectML, and CoreML.
What is MCP and how does it work with Java?
The Model Context Protocol (MCP) is an open standard that lets AI assistants interact with external tools and data sources. The official MCP Java SDK, maintained by the Spring AI team, provides both client and server implementations with sync/async support and multiple transports (STDIO, Streamable HTTP; SSE deprecated as of 2.0). Helidon MCP and several frameworks also offer MCP support.
Is Kotlin supported by Java AI frameworks?
Yes. Most Java AI frameworks run on any JVM language. Embabel is written in Kotlin with full Java interop, Koog from JetBrains is a Kotlin-native agent framework, and Tracy provides AI observability for Kotlin. LangChain4j and Spring AI work seamlessly from Kotlin code.
Recent & Noteworthy Content, Communities, and Resources
Talks, tutorials, books, and communities for learning AI development on the JVM.
Java Conferences Tracker
Community-maintained calendar of all Java conferences worldwide
BlogJava Relevance in the AI Era
RedMonk analysis of Java's position as agent frameworks emerge
ResourceAwesome Spring AI
Curated list of Spring AI resources, tools, and tutorials
BookSpring AI in Action (Manning)
Book by Craig Walls — comprehensive guide to building AI apps with Spring
BookUnderstanding LangChain4j
Book by Antonio Goncalves — explore the fundamentals of AI, learn the history and evolution of AI models, and understand the core concepts of LangChain4j
BookAI Agents with Java (O'Reilly)
Early-release book by Java Champions Alex Soto Bueno, Markus Eisele, and Mario Fusco — building long-running, stateful agents on the JVM with zero-trust security, RAG, and multi-agent coordination
BookApplied AI for Enterprise Java Development (O'Reilly)
Book by Alex Soto Bueno, Markus Eisele, and Natale Vinto — prompt engineering, RAG, guardrails, fault tolerance, and enterprise AI architecture using Quarkus, LangChain4j, and vector stores
ResourceProduction LangChain4j — Inside.java
Advanced RAG, agentic workflows, and production tips from Devoxx Belgium
ResourceGoogle ADK Java Codelab
Hands-on: build AI agents in Java with Google's ADK
VideosDevoxx YouTube
Thousands of conference talks on Java, AI, cloud, and architecture
VideosCoffee + Software
Spring ecosystem, AI integration, and Java community
ResourceFoojay Podcast: Java AI Revolution
Agents, MCP, graph databases — developers navigate the AI revolution
WorkshopBuilding Java AI Agents with Spring AI (AWS)
Hands-on AWS workshop for building intelligent AI agents with Spring AI and AWS services, including deployment to EKS
LivestreamAI & Java on Serverless Office Hours
James Ward and Julian Wood explore building AI-powered Java apps — MCP integration, agent architectures with AgentCore, GraalVM optimization for AI workloads, and secure auth patterns for AI services on serverless
VideosJava for an AI World — JavaOne 2026 Opening Keynote
Opening keynote of JavaOne 2026, featuring Rod Johnson, Josh Long, and engineering leads from Oracle, Microsoft, NVIDIA, JetBrains, and Uber on Java's AI direction, including the GitHub Copilot SDK for Java
VideosBootiful Spring AI — Josh Long & James Ward @ Spring I/O 2026
Talk from Spring I/O 2026 in Barcelona demystifying AI integration with Spring Boot — agentic patterns, Spring AI, and MCP integration
VideosJava and AI in 2026 and Beyond — James Ward Interview
68-minute interview with James Ward on the Code With Ease channel, recorded at GIDS Bangalore — the Java AI landscape from Spring AI, LangChain4j, Koog, and Embabel to MCP, agent memory, RAG vs tools vs skills, and production deployment with AWS AgentCore
Liberty LangChain4j Workshop
Hands-on, self-paced Open Liberty workshop that progresses from a simple chatbot to agentic systems using LangChain4j — prompt engineering, streaming, RAG, tool calling, MCP, guardrails/observability, and multi-agent supervisor patterns
ScarfBench
IBM Research's open benchmark for evaluating AI agents on enterprise Java framework migration — 102 applications and 204 tasks (~1,331 tests) covering Jakarta EE, Quarkus, and Spring, with a public leaderboard
Kotlin Benchmark for AI Coding Agents
JetBrains' open benchmark for evaluating AI coding agents on real-world Kotlin tasks — 105 issues drawn from active open-source Kotlin repositories including ktlint, detekt, and ort, each requiring the agent to read an issue, navigate the project, and produce a patch that passes the project's tests. Public leaderboard, built on the Multi-SWE-bench methodology.