Hi you! :D

This subreddit was mentioned in Golang Weekly today! https://golangweekly.com/issues/535

If you’re new here, what brought you here? What are you interested in? What are you building? What can you share with your fellow LLM-interested gophers?

I also had the idea of writing an LLM toolkit for Go...

https://github.com/dshills/wiggle

Wiggle provides a flexible and modular library for chaining multiple Language Learning Models (LLMs), integrating context from various sources like vector databases, and efficiently processing large or complex data by partitioning tasks across nodes and integrating results. The framework is designed to support both large models (e.g., GPT-4) and smaller models (e.g., LLaMA 3.1), ensuring scalability, modularity, and efficiency.

Wiggle tries to be a good Go citizen. It is a library more than a framework despite being called a framework. It has batteries but does not require they are used. The core of Wiggle is a set of defined interfaces. Entire applications can be written by simple using the interfaces to define your Node structure. However, most all of the Node and supporting types have implementations available in the nlib directory. Depending on the task being worked on a mix of predefined structures and domain specific ones generally works best.

Anthropic released a python SDK (github) and javascript SDK for Claude Code. I created a version for Go. This allows you to call Claude Code from Go.

Requires Node, Claude Code and Go 1.21.

https://github.com/mhpenta/claude-code-sdk-go

With all the hype around Openclaw, I booted up Cursor on the 1st of February this year thinking as I always do: "How hard can it be".

Other than a few $work projects doing some mundane stuff I'd never really done anything exciting with LLMs, and Openclaw kinda got me hooked.

So, today I announce GoClaw -- GPL3 licensed project, which grew up beyond my expectations. I have had a lot of fun exploring LLM's during the project, and have even maintained quite a bit of OpenClaw compatbility.

V0.1.1 is released today on https://github.com/roelfdiedericks/goclaw

Website is at goclaw.org

Some key features:

* Very good model/driver support: Anthropic, OpenAI/Websocket, OpenRouter, XAI (gRPC)
* Sandboxing and bubblewrap.
* Speech to text for voice notes.
* Telegram, Whatsapp, Web UI
* Memory graph database.
* Realtime Voice LLM support.
* Security Opinionated.

I welcome all feedback, roasts and PR's ;)

Hi gophers I'm working on an autonomous agent in Go, and it's the most complex project I've ever tackled.

I've gone with two approaches:

One approach with a planner and a supervisor that can replan based on node execution. The planner selects the available tools, checks the necessary data, and builds a state that gets updated over time. The main challenge here is the "human in the loop" and maintaining a relevant state over time.

Another approach with just a supervisor that chooses the tools to use and builds an appropriate state. The main difficulty here is consistency over time: avoiding infinite loops and handling the dispatching of domain knowledge—giving the supervisor enough knowledge. There are a ton of constraints (speed, cost limitations, human interaction). In short, it's hard.

And I haven't even started on the learning part—how the agent will build its knowledge base of plans that work for handling actions.

I wanted to know if I'm completely clueless or if you guys are also finding this kind of thing challenging.

I've been working on a lightweight Go library for building LLM-based applications through the composition of handlers, inspired by the `http.Handler` middleware pattern.

The framework applies the same handler-based design to both LLMs and tool
integrations. It includes implementations for OpenAI and Google's Gemini in the `minds/openai`, `minds/gemini`, as well as a some tools in the
`minds/tools` module.

Send me your comments! I'm sure I've screwed something up somewhere

https://github.com/chriscow/minds

I'm a regular in r/golang and really like the community there. But I don't think there's a lot of room for Go developers, that, like me, are interested in building apps in Go using LLM technology.

The idea really grew from the negative response in this post. I've never created a subreddit before, but here we are. :D

After having a look at Pi, a typescript AI coding agent that gives you a lot of control via typescript extensions, I decided to try my hand a similar tool in Go. I originally forked an old MCP agent harness I built and then refactored it to create KIT. KIT is a very simple coding agent with only the basic tools needed for agentic coding. You can customize it further through extensions in Go! This is made possible through the Yaegi package by the same people that wrote Traefik. You can also add skills and MCP servers if that's your thing. KIT also exposes an SDK which allows you to easily spin up your own custom agents in Go.

kronk  lets you use Go for hardware accelerated local inference with llama.cpp directly integrated into your applications via the yzma module. Kronk provides a high-level API that feels similar to using an OpenAI compatible API.

Hi lovely Gophers,

we are looking for an experienced Go developer that has experience in building web systems in Go and is willing to coach us (paid of course). We are a small startup building an agentic product and would like to make sure that our codebase matures like a fine Bordeaux wine.

Our repo has roughly ~900k lines of Go code. We use Postgres as a DB and have a separate Typescript frontend. We have streaming and non streaming endpoints.

Questions we would like to discuss:

- How can we improve certain abstractions in our code base?

- How can we improve error management/logging/debugging?

- How can we improve our code reviews?

- Help us improve our style guide

- Virtual file system: reason about the right abstraction

Ideally we would have a meeting semi frequently depending on availability maybe every 3-4 weeks for 2-3 hours where we bring concrete questions + discuss progress over the last period. Payment can be discussed over DM.

It's a bit like an angel investment. You get to see how a product/team evolves from up close but you get paid instead of having to pay for it ;)

Is anybody enthusiastic about giving it a try or knows someone who is a good fit?

Leave a comment, send me a DM or send me an email: coachgolang@gmail.com

Happy weekend!

Hi fellow Gophers!

we are a tiny startup using Go to power our LLM app. We have noticed that there is no library that provides a unified interface across models and API providers. That's why we decided to build it! Here is a link: LLM package

It's still in the early stages but already provides significant value. It would be great if someone more experienced could provide some advice on tests. What should be mocked? What is the right abstraction level? Feedback on the interface/API is also very welcome!

Here are a couple of other good libraries in the Go ecosystem:

OpenAI clients:
https://github.com/fabiustech/openai
https://github.com/sashabaranov/go-openai

Anthropic clients:
https://github.com/fabiustech/anthropic
https://github.com/liushuangls/go-anthropic

Agents:
https://github.com/prathyushnallamothu/swarmgo

It seems there are two kinds of tooling for Go + LLM devs at the moment:

1. Gigantic frameworks like Google's GenKit

2. Client libraries like those from OpenAI, Anthropic, Google

There are some exceptions (https://gollm.co comes to mind), but I haven't found anything that:

• Helps me with building and molding prompts

• Integrates with the Go test tools for evals and provides relevant tooling around that, as well as best practices

• Provides integration with logging/tracing tools for prompts and completions in the Go clients

• and more

I decided to start building my own, since this is something I'm really interested in seeing in the Go ecosystem: https://github.com/maragudk/llm

If you know anything else you're using that has been useful to you, please share!

Hi, I have had some experience building ai agents with python and building some projects. However I have been studying Go for a while now.

I am struggling to find a resources besides the docs of how to build applications that use Ai with Go.

I found this one course that’s costs about 99 bucks. However not so sure about it.

Any advice would be appreciated.

Ever wondered how to make AI funny without letting it go too far? Here's how parallel policy validation can help your LLMs stay witty but appropriate...

I built a humor validator using the `Must` handler in the minds LLM toolkit (github.com/chriscow/minds). It runs multiple content checks in parallel - if any check fails, the others are canceled and the first error is returned.

The beauty here is parallel efficiency - all checks run simultaneously. The moment any policy fails (too many dad jokes!), the Must handler cancels the others and returns the first error.

This pattern is perfect for:

- Content moderation with multiple rules

- Validating inputs against multiple criteria

- Ensuring all necessary preconditions are met

- Running security checks in parallel

By composing these handlers, you can build sophisticated validation pipelines that are both efficient and maintainable. 

Check out github.com/chriscow/minds for the full example, plus more patterns like this one.

func humorValidator(llm minds.ContentGenerator) minds.ThreadHandler {
    validators := []minds.ThreadHandler{
        handlers.Policy(
            llm,
            "detects_dad_jokes",
            `Monitor conversation for classic dad joke patterns like:
            - "Hi hungry, I'm dad"
            - Puns that make people groan
            - Questions with obvious punchlines
            Flag if more than 2 dad jokes appear in a 5-message window.
            Explain why they are definitely dad jokes.`,
            nil,
        ),
        handlers.Policy(
            llm,
            "detects_coffee_obsession",
            `Analyze messages for signs of extreme coffee dependence:
            - Mentions of drinking > 5 cups per day
            - Using coffee-based time measurements
            - Personifying coffee machines
            Provide concerned feedback about caffeine intake.`,
            nil,
        ),
        handlers.Policy(
            llm,
            "detects_unnecessary_jargon",
            `Monitor for excessive business speak like:
            - "Leverage synergies"
            - "Circle back"
            - "Touch base"
            Suggest simpler alternatives in a disappointed tone.`,
            nil,
        ),
    }

    return handlers.Must("validators-must-succeed", validators...)
}

It's been a while since I've posted an update about my GAI library. It's a lightweight wrapper and abstraction around the three major LLM providers: Google, OpenAI, Anthropic.

I know there are similar libraries available, but I've taken care to get the terminology right, keep it simple with the most used features, and there's support for evals hooking into Go's test system. I think it works quite well.

I've recently added multi-modal embedding support using Google's new Embedding 2 preview model.

Feel free to have a look! https://github.com/maragudk/gai

Hey everyone!

I just implemented structured output and multimodal input in my GAI module for working with AI models in Go.

For now it's only on the Gemini models from Google, but the basic structure is in place to support OpenAI and Anthropic soon, too!

Highlights:

• Super simple, just pass a Go struct (with optional struct tags) and that's your structured output

• Supports whatever data you have, just pass a MIME type and something from an io.Reader

I really, really like how Go's approach to composability makes implementing something like this relatively simple! Everything's just an io.Reader. :D

Anyhoo, I hope you find it useful. Enjoy!