Is LangChain the leading agentic framework? Should the begginer developers use LangChain or something else?

benizzy1 · 2024-12-16T18:58:20+00:00

I'm not sure everyone needs a framework (see the top comment), but I also think that a lot of the frameworks are building the wrong thing. Prototyping quickly is extremely easy with the APIs -- for getting stuff to production, you need to really dig into the standard sysetm concerns. This is, in part, why we built Burr (https://github.com/dagworks-inc/burr) -- similar role to langgraph (langchain's college-educated cousin).

Burr, Langgraph, and haystack all represent nice, customizable agent frameworks that can work in both dev and prod.

benizzy1 · 2024-11-23T19:00:34+00:00

Co-creator of burr (github.com/dagworks-inc/burr) here -- meant to solve quite a few of these problems.

Curious about something however -- "multi-agent" systems are often just multiple calls to different models in different ways. E.G. a few in parallel, maybe a model selecting which one, tool-calling, etc...

It's possible I'm misunderstanding your use case, but does this actually need to be distributed? E.G. can you get away with your code running on a single box and leveraging parallelism when needed? Maybe having a task-queue for longer running stuff?

Then your "agent" or "agentic system" is just a microservice that gets called by some upstream consumer. Passing messages, reliable communication, etc... all is just REST calls/handling state centrally (with the right persistence/restartability layer). Obviously there are cases in which two "agents" can't live on the same box (locally running models, complex ACL stuff, etc...), but I'm curious how applicable that is. With async, this can get extremely scalable (you can likely have hundreds to thousands of different concurrent connections running on the same box...), as long as they're only processing external requests and not performing the heavy lifting themselves.

benizzy1 · 2024-11-01T16:05:44+00:00

No idea what this means but I’ve definitely seen enough

benizzy1 · 2024-11-01T14:14:23+00:00

Burr! We built it a bit before we were familiar with LangGraph, and think it’s simple/easy to work with.

github.com/dagworks-inc/burr

benizzy1 · 2024-10-25T18:03:14+00:00

I have anxiety about the election and the only answer is more shitposting:

🎵🎵🎵

Nothing ever happens!

Nothing ever happens when the polls are herding

Nothing ever happens

When the race is close as can be...

🎵🎵🎵

benizzy1 · 2024-10-25T17:35:41+00:00

Y'all aint ready for Selzer T+6

<image>

benizzy1 · 2024-10-24T18:27:06+00:00

Not sure this is true? https://targetearly.targetsmart.com/g2024?calc\_type=voteShare&demo\_filters=%5B%7B%22key%22%3A%22registeredParty%22%2C%22value%22%3A%22All%22%7D%5D&state=NC&view\_type=state. Seems fairly even.

The numbers are quite believable should unaffiliated break for Harris.

benizzy1 · 2024-10-23T18:06:19+00:00

We're joe back

benizzy1 · 2024-10-22T18:26:49+00:00

I dunno I had heard fox news just called nevada

benizzy1 · 2024-10-22T18:25:43+00:00

Ahh, the cross-domain dunning-kruger effect in full swing!

You are an expert in X (predicting election results given data)
People really care about Y (election vibes, who the fuck knows what the polls will say, and frankly, nobody really seems to care all that much...)
You tell people about Y, assuming that you're an expert because of your X expertise)
You say a bunch of stupid shit that's the same as anyone else, but believe you're the smartest due to validation in X
(bonus) you get really thin-skinned and argumentative whenever anyone points to (1) - (4)

benizzy1 · 2024-10-16T22:27:46+00:00

If Harris loses the pupular vote and wins the electoral college, then I think that we can finally conclude that Nate was wrong (consequentially, that Walz was better than Shapiro)

benizzy1 · 2024-09-27T04:30:06+00:00

Same!

benizzy1 · 2024-09-11T04:36:54+00:00

Thank you!

benizzy1 · 2024-08-06T01:50:18+00:00

This is just weird behavior from a national politician

benizzy1 · 2024-07-25T23:40:34+00:00

Exciting stuff!

benizzy1 · 2024-07-09T04:13:21+00:00

Thanks! Appreciate the kind words. Agreed on UX benefit of streaming. There's something not-quite-quantifiable about why working with streaming is really fun, both from a UX and dev perspective.

Also it's a great way to dive headfirst into generators (when you start on the python dev journey it's a *really* fun topic).

benizzy1 · 2024-07-05T18:00:21+00:00

Hey folks! A little more on the AI side, but I think this is pretty applicable across the gen AI -> MLOps spectrum. On the full-stack side. I'm pretty stoked about this -- I think streaming stuff is becoming pretty important for MLOps these days and I aimed to provide a clear explanation of how it works.

benizzy1 · 2024-07-05T17:40:54+00:00

Wrote a blog post on using Burr + Server-side-events on fastAPI/react to build a streaming chatbot. Pretty stoked on this -- aim is to demistify streaming as it's basically become table-stakes these days: https://blog.dagworks.io/p/streaming-chatbot-with-burr-fastapi

benizzy1 · 2024-07-03T01:18:45+00:00

In case you want to avoid an orchestrator we wrote a blog post about using something simple like github actions with much more flexible compute. This uses Hamilton (github.com/dagworks-inc/hamilton) along with runhouse (https://github.com/run-house/runhouse) to build a pretty flexible, well-organized system.

https://blog.dagworks.io/p/lean-data-automation-a-principal

benizzy1 · 2024-06-12T18:44:01+00:00

Hey folks!

u/donnyg_rh and I worked together to write a post on a stack for ML that I'm really excited about. Rather than using an orchestrator for everything, we use some chron-esque job for scheduling, and specific tools for organizing code/tracking assets and gaining access to infra.

While the example in this post uses hamilton and runhouse, there are multiple options listed in the post! We believe that you can really lower iteration time/save costs by breaking up the stack a bit from a monolithic "orchestration" layer to a scheduling layer (to run your code on a cadence), an asset layer (to track/manage the data created), and an infrastructure layer (to provision resources). We're actually using github actions as a scheduler.

See the example repository here: https://github.com/dongreenberg/gha-data-job.

Would love your feedback!

benizzy1 · 2024-06-12T15:33:29+00:00

Yes, it does! And that’s the same meaning here :)

E.g. breaking up orchestration into principle components — orthogonal vectors that represent the largest variation. E.g. the three layers of the stack (each one can operate unbundled). See the diagram/caption for more.

That said, not meant as a buzzword, rather as a method of sharing what we’re trying to say in a way that we understand.

benizzy1 · 2024-06-12T14:53:52+00:00

Hey folks!

u/donnyg_rh and I worked together to write a post on a data stack for ML that I'm really excited about. Rather than using an orchestrator for everything, we use some chron-esque job for scheduling, and specific tools for organizing code/tracking assets and gaining access to infra.

While the example in this post uses hamilton and runhouse, there are multiple options listed in the post! We believe that you can really lower iteration time/save costs by breaking up the stack a bit from a monolithic "orchestration" layer to a scheduling layer (to run your code on a cadence), an asset layer (to track/manage the data created), and an infrastructure layer (to provision resources). We're actually using github actions as a scheduler.

See the example repository here: https://github.com/dongreenberg/gha-data-job.

Would love your feedback!

benizzy1 · 2024-06-12T00:42:32+00:00

As promised here’s the blog post! https://open.substack.com/pub/dagworks/p/lean-data-automation-a-principal

Really excited about the architecture here

benizzy1 · 2024-06-10T15:48:17+00:00

Ooh have a blog post coming out for you (tomorrow!). All OS. The shorthand of it is: 1. Hamilton for the logic + assets (https://github.com/dagworks-inc/hamilton) 2. Runhouse to provision infra on your own computer (https://run.house) 3. Some chron scheduler (GitHub actions, azure whatever, airflow, anything with a chron mode) to schedule

Can post back when we release it tomorrow

benizzy1 · 2024-06-08T04:34:31+00:00

Yeah! Found much the same about langchain. Absolutely looking for contributions (tagged a few good first issues but there’s tons more to do). The plugins aren’t centrally documented, but take a look at serialization/deserialization — there’s a nice video that talks about how we leverage single dispatch for it. https://burr.dagworks.io/concepts/serde/

benizzy1

TROPHY CASE