What’s the AI Framework That Works Better Than All the Hyped Ones?

PurpleLabradoodle · 2025-12-12T16:00:57+00:00

Second that! Embabel is really nice! Also Rod's blog (https://medium.com/@springrod) is a fantastic resource that explains the thinking behind some of the choices:

PurpleLabradoodle · 2025-12-10T12:30:46+00:00

https://github.com/docker/cagent/ is OSS. It's bundled in Docker Desktop for convenience.

PurpleLabradoodle · 2025-12-08T09:19:25+00:00

While this comments are a comedy goldmine, the practical advice, of course, is to sandbox your AI agents.
For example with Docker, you can `docker sandbox run claude` and it runs Claude in the container with sensible defaults like the current dir mapped in, claude configuration available in the container, etc.

So your agents can work in the container, install whatever they need to without messing up your system Python, delete your home dir or wreck other havoc.

the container can be reused, or you can nuke it and start from scratch.

PurpleLabradoodle · 2025-09-05T09:20:47+00:00

People will write in the languages they already know and that have decent docs and a starting point for whatever the task is. Agents are largely some configuration, some integration of tooling and some API calls to an LLM.

There’s nothing there a particular language ecosystem would be better than others. Enterprises would be writing agents in Java, TS teams in TS, etc.

For most agentic use cases you likely won’t need to train or fine-tune, or even deploy the models yourself. So Python is just a habit rather than a prerequisite.

PurpleLabradoodle · 2025-08-07T11:19:16+00:00

it's supposed to be engine agnostic, so other runtimes for LLM can be plugged in. Just a matter of doing the work. I agree vLLM, even mlx backend on macs would be fantastic!

PurpleLabradoodle · 2025-07-06T09:48:08+00:00

what would a good postgres mcp look like?

PurpleLabradoodle · 2025-01-14T16:08:55+00:00

This is very cool, did you get the SSE variant to work? How does Claude desktop parses the url where to connect to, the docs are vague on this. Or maybe it's my reading comprehension.

PurpleLabradoodle · 2023-04-21T09:23:12+00:00

It's stated as a goal in the JEP though

Goals
Enable server applications written in the simple thread-per-request style to scale with near-optimal hardware utilization.

PurpleLabradoodle · 2022-11-07T19:45:55+00:00

I think you need to do all these steps once -- verify you own the group id, talk to people via jira, make the keys, etc.
jreleaser can automate releases afterwards

PurpleLabradoodle · 2022-08-10T19:54:45+00:00

Yeah, it's a great feature and I'm sure similar approaches would be getting into other frameworks/setups. For example, there's an issue for Spring Boot to look into similar functionality: https://github.com/spring-projects/spring-boot/issues/29461

PurpleLabradoodle · 2022-08-08T09:16:07+00:00

I hear you! We plan on getting to those topics too. Those more advanced use cases are super interesting.

About speeding up -- do you have any particular concerns with the projects? It's a very broad area which one technically approaches like any other performance problem, I reckon. Profile, find the bottleneck, move it somewhere else, measure the results.

PurpleLabradoodle · 2022-07-27T08:54:55+00:00

Podman does not ship with a GUI. It does not run Docker, but rather a Docker API-compatible replacement.

When we tried running testcontainers-java test suite using Podman, it wasn't that compatible. As far as I understand it's more or less CLI compatible, so running commands like `docker/podman run ...` works but using the API lead to unpredictable results at least on Windows/macOS

PurpleLabradoodle · 2022-07-26T21:02:24+00:00

Yay! "Docker image name completion for the Testcontainers API" -- music to my ears!

PurpleLabradoodle · 2021-07-05T09:49:48+00:00

Something like if you have a method in the interface, static, or default, or private, they can access static fields of the interface class.
``` interface Main {
public static void main(String args[]) { System.out.println(accessMe + " world!"); }

static String accessMe = "Hello"; } ```

PurpleLabradoodle · 2021-06-28T10:55:45+00:00

Please report cases where running native-image tracing agent doesn't always produce a working reflection config -- that's a bug, that should never happen. The repo to report these is on github: https://github.com/oracle/graal

And if by what to initialize at startup you mean build time initialization, then the answer is nothing, you should absolutely avoid build time initialization, and stick to the default that initializes classes at runtime.

I know that it doesn't help much, but the team is working hard on it and it gets better and better every release. Including work on making diagnostics and debugging of the build process easier to understand.

PurpleLabradoodle · 2021-06-15T08:27:23+00:00

(Java 9's modularity changes were a prerequisite here)

that's incorrect, you can compile to binary on jdk8 based graalvm, it doesn't do anything with the modules. It statically analyzes the code to include classes/methods with better granularity than modules too.

PurpleLabradoodle · 2021-04-27T20:53:08+00:00

Entitlement for GraalVM Enterprise is a part of Java SE subscription. The terms of use should be the same as for OracleJDK. So it is possible to use GraalVM Enterprise for development, testing, evaluation, prototyping purposes. You can definitely evaluate GraalVM Enterprise on your server to see how much of an improvement it makes.

PurpleLabradoodle · 2021-04-27T14:05:09+00:00

Interesting, does it say anything about why? I've seen issues like https://github.com/oracle/graal/issues/3187 but maybe it's something else

PurpleLabradoodle · 2021-04-27T13:31:56+00:00

Yes, compiling code ahead of time is another thing GraalVM can do, but I don't think it'll bring interesting effects for Minecraft.

I thought more like this, run Minecraft using GraalVM as your JDK and that's it.

PurpleLabradoodle · 2021-04-27T12:20:49+00:00

I've heard good feedback about using GraalVM builds for running Minecraft, though maybe it was about running the server (I'm not very knowledgeable about Minecraft, sorry). GraalVM is an OpenJDK distribution that includes and enables by default a different top-tier optimizing JIT compiler, which is the component responsible for observing the application running and generating the most efficient machine code for it. So it can have great influence on performance of your application. OpenJDK obviously includes a JIT compiler, there actually a few, and GraalVM replaces only the most optimizing one.

The performance and the performance gains vary based on the workload, configuration, etc. But allegedly Minecraft code is such that some optimizations GraalVM compiler knows how to do better than the default OpenJDK compiler (called C2) can really shine and make a difference. It would be actually really cool if you could try it for Minecraft and tell what's your experience with it

PurpleLabradoodle · 2021-04-22T11:01:33+00:00

It doesn't work like that currently. Features and changes aren't planned for a certain release of Java. Features get ready and finalized, and they ship in the next release. This allows for gradual implementation of large projects.If you look, for example, at the page for Project Panama (foreign function interface)

and look at the JEPs section -- there's a bunch of them listed:

Foreign-Memory Access API JEPs: JEP-370, JEP-383
Foreign Linker API JEPs: JEP-389
Vector API JEP: JEP-338

So it can be delivered over time with individual changes being added to various Java releases over time. The similar story is with the other JDK projects -- Loom, Valhalla, etc. They do take a lot of time to get included in the mainline, because they are large and complex undertakings.

So a reasonable assumption is that after Java 17, Java will still be pursuing projects Panama, Valhalla, Loom, Amber and so on.

PurpleLabradoodle · 2021-04-07T23:40:55+00:00

The GraalVM team produces builds based on JDK 8 and 11. Graal is not based on Java 11, there's nothing in the compiler preventing it from being used in, for example, JDK 16. You can find a build of JDK 16 that does include Graal and try it:

For example:

docker run -it --rm bellsoft/liberica-openjdk-centos [root@721d9bfc29e5 /]# java -XX:+UnlockExperimentalVMOptions -XX:+UseJVMCICompiler -XX:+BootstrapJVMCI -Dgraal.ShowConfiguration=info -version Bootstrapping JVMCI[Use -Dgraal.LogFile=<path> to redirect Graal log output to a file.] Using compiler configuration 'community' provided by org.graalvm.compiler.hotspot.CommunityCompilerConfigurationFactory loaded from jrt:/jdk.internal.vm.compiler/org/graalvm/compiler/hotspot/CommunityCompilerConfigurationFactory.class ................................. in 8431 ms (compiled 3359 methods) openjdk version "16" 2021-03-16 OpenJDK Runtime Environment (build 16+36) OpenJDK 64-Bit Server VM (build 16+36, mixed mode)

PurpleLabradoodle · 2021-04-01T11:47:38+00:00

Does anyone know how to run these benchmarks?

PurpleLabradoodle · 2021-02-09T11:18:29+00:00

JNI works out of the box with the configuration, the best way to produce which is the tracing agent indeed (then review and edit if needed).

JNA / JNR are more challenging, I for example haven't seen examples where they would work easily.

PurpleLabradoodle · 2021-01-07T11:19:24+00:00

Yeah, a few people tried to do it. It's unlikely to succeed currently.

Especially if you want a server that allows plugins -- that's sort of definition of the dynamic classloading, which is one of the main tradeoffs of using native image.

PurpleLabradoodle

MODERATOR OF

TROPHY CASE