traviscline

Been using these types of flows across agent harnesses for a while. Check out https://github.com/tmc/it2

I’m seeing this even in RecoveryOS after a fresh MacOS install..

Can others check logs on MacOS and iOS devices?

https://github.com/tmc/mcp/blob/next/cmd/mcpdiff/testdata/sc...

This is what the tests look like, for both the tools and to validate the servers.

In the current state you can insert “mcpspy” in front of a server and it intercepts and streams out a plain text format that’s nice for humans and machines. There’s also a replay tool that emulates previous traffic, including in mock client and server modes, and a diffing program that is mcp protocol aware.

Oh, and most importantly, a vim syntax plugin for the .mcp file format.

Thanks for this, I’ve been feeling similarly.

I’m working on some Go programs/tools with the explicit goal of describing existing servers in a language neutral manner to try to get some sanity into the mix.

I was reenergized to pick this back up because Google is working on a version so I want to get these tools ready.

Open to ideas and input, have been noodling on it for a bit now, lots not in form to share but figured I’d share early:

https://github.com/tmc/mcp

See https://news.ycombinator.com/item?id=38475745 / https://github.com/tmc/langchaingo for a closer-to-langchain alternative.

I've been building+maintaining this Go-idiomatic port of langchain concepts to Go.

We're gaining a bit of traction and would love input, feedback, and contributions.

we have some nascent docs+tutorials here:

https://tmc.github.io/langchaingo/docs/getting-started/guide...

And a ton of examples here: https://github.com/tmc/langchaingo/tree/main/examples

You might be interested in https://github.com/tmc/langchaingo which adheres to some of the conceptual modeling in langchain.

This is cool -- I wrote something a bit similar here but uses just raw Go as the source input: https://github.com/tmc/go2oapi

I used this library for inspiration and extended to write some cli tools for use from vim: https://github.com/tmc/notion/tree/master/cmd

https://github.com/tmc/notion/tree/master/cmd Has some tools

https://github.com/tmc/notion/tree/master/cmd I wrote some tools to use notion from vim.

Some cli tools here: https://github.com/tmc/notion/tree/master/cmd

I use these plus some vim recordings to do bidi synchronization of buffers

You might consider https://godoc.org/github.com/tmc/grpcutil/protoc-gen-tstypes

typos: memeory, "pulling the struct iovec abart."

Nothing official but I have a prototype that exposes a parse schema via GraphQL here: https://github.com/tmc/parse_graphql

Just pushed a tool that shows you your margins using the MtGox streaming api: https://github.com/tmc/btcmargin

Do you not recall those recent strikes?

Interesting, I've had an almost opposite experience, but I don't know the ruby landscape all that well (bundler/gemsets/rbenv/rvm etc) and I suppose it just depends on what background you're coming from.

FWIW, when creating a virtualenv the -p flag lets you choose a python binary (and therefore version).

Great writeup. This shows the power of gevent+redis really succinctly.

I think most importantly vs a twisted or tornado based solution this is using the vanilla redis client library. As long as your datastore's client library is pure-python it JustWorks with gevent.

Adding gevent-websocket and gevent-socketio to the mix gives some interesting possibilities as well.

Good call, added it, initial run didn't show a huge difference.

edit: here are numbers from a few runs: gvent,http.go 361.43,386.68 354.69,397.15 388.96,377.69 424.81,430.34

http.go averaged 26% utilization gvent.py averaged 15% utilization

I'm embarrassed posting this because of how grossly unscientific this is..

Not quite as fast as I thought initially but likely faster than the other python competitors.

See my other comment, gevent appears to outperform in my initial test.

Added a basic gevent example here that is apparently about 10% better than the http.go wrt transaction rate.

https://github.com/traviscline/web_bench

(notice: I realize this is a highly synthetic benchmark and reading siege results like this is not good benchmarking)

Did some filter-branching and rebasing to get tav's work on top of current master: https://github.com/traviscline/fabric/tree/tav

Is this really a better approach than using Cython to wrap a c++ or c implementation?

I'm not aware of any commercial solutions but a tool you might find useful is Hive: http://hadoop.apache.org/hive/

These videos are a great introduction: http://www.cloudera.com/videos/introduction_to_hive http://www.cloudera.com/videos/hive_tutorial

I dig http://www.redmine.org/ I think it hits most of your needs.

The possible workflows with git encompass hg workflows. You're obviously not interested in gaining anything but self-fulfillment throughout this thread.

Actually, git supports more workflows, you could simply implement read-only branches with a naming scheme and a hook.

In lots of ways git is a superset, branch workflow included.

I don't really see much value in keeping a branch around after development is complete (or defunct).

If the work is complete then merge it (with no-ff if you want to show the merge explicitly). If it's defunct then delete it. If you want to keep it around but discourage further development then tag it or come up with a naming convention.

That you have the ability to mark branches as closed in mercurial is mainly paper over their odd decision to not allow deletion of branches.