[arunmu]

> No LangChain, no LangGraph, no LlamaIndex, no CrewAI

Bless you. Using these over complicated abstractions (except CrewAI which I haven't yet checked out) never made sense to me. I understand that LLM is no magic wand and there is a need to make it systematic rather than slapping prompts everywhere. But these frameworks are not the solution to it. Next I will be looking at is Microsofts semantic-kernel. Anybody has any good words for it ?

[asabla]

Built a couple of things with Semantic Kernel. Both some private test projects, but also two customer facing applications and one internal.

It's heavily tilted towards OpenAI and it's offerings (either through OpenAI API or through Azure). However, it works decent enough for other alternatives as well, like: huggingface or ollama. Compared to the others (CrewAI etc). I kind of feel like Semantic Kernel hasn't really solved observe ability yet. Sure you can connect what ever logging/metric solution .Net supports, but it's not as seamless like the others. Semantic Kernel is available in .Net, Java and Python. But it's quite obvious .Net is a lot more polished then the others. Python usually gets new features faster, or at least pocs or previews.

Some learnings from it all:

- It's quite easy to get started with

- I like the distinction between native plugins and textbased ones (if a plugin should run code or not)

- There is a feeling of black magic in the background, in the sense of observe ability

- A bit more manual work to get things in order, compared to the alternatives

- Rapid development, it's quite clear the development team from Microsoft is doing a lot of work with this library

All and all, if you feel comfortable with writing C#, then Semantic Kernel is totally a viable option. If you prefer python over anything else, then I would say llamaindex or langchain is probably a better option (for now).

edit: updated some formatting

[arunmu]

Thanks. I would have preferred to use Go instead of Python, but somehow the language is not picking up a lot in terms of new LLM frameworks.

As of now, I am using very light weight abstractions over prompts in python and that gets the job done. But, it is way too early and I can see how pipelining multiple LLM calls would need a good library that is not too complex and involved. In the end it is just a API call and you hope for the best result :)

[asabla]

Since you prefer go, you might be interested in one of my pet projects. Where I've glued together some libraries, which lets you basically code all interactions with LLM's through lua. The project is written in go.

Currently it only supports ollama, but I've been thinking about adding support for more providers

[PhilippGille]

At which url can we check it out? Didn't find it on your profile and Github user with same username seems to be someone different.

[asabla]

Sorry about the late response. Thought I already had pushed it, you can find it here: https://github.com/asabla/gogent

As you can see, it's in a very early stage. I'm not a go developer, and I use this repository as a way to explore things both within Ollama and with go.

I'll probably add more things as the time goes by, but it isn't something I hack on every day or for that matter week. Just something to poke around and explore things with.

[ActionHank]

I'm currently building some stuff with SK using csharp.

Biggest gripes are that APIs have been changing quite a bit over time and the documentation isn't exhaustive in describing what is available.

If you're comfortable digging around in the source, looking at their tests and piecing things together it's pretty solid to build off of and is working well for me thus far.

I really like that there is abstraction enough for me to use other LLMs or implement them if need be.

I echo your apprehension around these abstractions and have built closer towards some of OP's patterns.

[jackmpcollins]

I'm working on a very abstraction light package for LLMs called magentic. The goal is to handle the main boilerplate of building with LLMs, but leave the abstractions up to the user. I'd be interested to hear your opinion on it vs others.

https://github.com/jackmpcollins/magentic

[digdugdirk]

Interesting! How does it compare to something like Mirascope? I feel like I'm constantly on the hunt for the slimmest llm interface layer, and mirascope is my most recent attempt.

[ErikBjare]

I found `ell` pretty appealing, but I still prefer using the raw openai/anthropic packages.

[wildermuthn]

Check out dspy. It gets out of the way for the most part, while giving optional prompt optimization tooling that future-proofs your work.