topicseed

I'd say out of many generative AI observability platforms, Langsmith and Weave (Weights&Biases) are probably the ones most enterprises use, but there's definitely space for Langfuse, Modelmetry, Arize AI, and other players.

No but most models have their own libs you can use

I kind of agree but the same problem exists. If you add text-xl to a div and have nested divs and spans, they'll all be inheriting text-xl so for these nested elements, you also have to look up the element's lineage to find what's causing the text-xl.

But overall it's a bit easier yes.

Just played with it and it's great! A good 2.0 release I think.

Is it on AI studio already?

A great option for Go projects where you aren't exploring your queries as changing and regenerating is cumbersome.

Also, SQLC doesn't allow for dynamic query building so think about an input search struct from which you may add where clauses — or not.

Also doesn't support multiple inserts with N rows being inserted.

Otherwise for standard queries, it's great.

Evaluate them how? Specifically the voice/audio or you're happy to evaluate them with the transcript with something like Modelmetry?

Do they build guardrails themselves or do they use an llm guardrail api like Modelmetry or Langwatch?

1k rps per bucket though ...

An improved and more interactive version of Google Sheets' explore tab. Looks good!

The "YC" part.

what exercises do you recommend for these auxiliary muscles?

Quick question, what do you use such an observability platform for? Can't be the price as you get it straight from Openai's dev dashboard. So what else do you use Languse for?

Nice to have:

> Conditional use() (unline current hooks)

> Support for Document Metadata

> Support for stylesheets

> Support for async scripts

> Support for Custom Elements

Probably like what happened with Google Inbox... It's a greenfield canvas to try a lot of innovations, see which ones people use, then shut down the product and add these popular features to Gmail, or in this instance, Slides.

Thank you for the thorough response!

What specific strategies does Hatchet employ to guarantee fault tolerance and enable durable execution? How does it handle partial failures in multi-step workflows?

Superset works wonders

Gemini 1 Ultra was also said to be on par with ChatGPT 4 and it's not really there so let's see for ourselves when we can get our hands on it.

Is this going to be only for consumer Gemini app or for API/Vertex too? The context window is..... Simply lovely.

1 million tokens?? This is wild and a lot of RAG can be removed.

Is this essentially implemented via RAG?

New chat comes in, they find related chats, and extract some instructions/context from these to feed into that new chat's context?

You do have to instantiate that struct, and you can do it with.... a beautiful NewCreateUser(dep1, dep2, dep3, ..., dep20) *CreateUser {...}. This is essentially what he recommends with his "func newMiddleware() func(h http.Handler) http.Handler".

I've always have my handlers individually set as a struct each with a method to handle the route/request.

type CreateUser struct {

   store  storage.Store

   cache  caching.Cache

   logger logging.Logger

   pub    events.Publisher

   // etc

}

func (op CreateUser) ServeHTTP(ctx, req, rw) {}

// or if you have custom handlers

func (op CreateUser) ServeHTTP(ctx, input) (output, error) {}

And in my main.go, or where I set up my dependencies, I create each operation, passing it its specific dependencies. I love that because I can keep all the helper methods for that specific operation/handler on that specific struct as private methods.

It does get tedious when you have one operation needing another, as you might start passing these around or you extract that into its own package/service.

Or, if you're more into publishing an Openapi spec from your Go code, I do like danielgtaylor/huma[1] and swaggest/rest[2].

[1] https://github.com/danielgtaylor/huma

[2] https://github.com/swaggest/rest

> We first struggled with token limits [solved]

How has this been solved in your opinion? Do you mean with recent versions with much bigger limits but also heaps more expensive?

Opacity maybe would help here.

The option to enable that is using double quotes for the most part, no?

e.g., fuzzy text matching => "fuzzy text matching"