To discover where the widely used python package certifi reads its certificates from, run:

    python -m certifi

Print the available filesystem types:

    cat /proc/filesystems

# How can I set up gvisor to route packets from my TUN onwards to the internet, and back again?

Clues: stack.LinkEndpoint and stack.NetworkDispatcher

LinkEndpoint contains NetworkLinkEndpoint interface, which has the following:

	// Attach attaches the data link layer endpoint to the network-layer
	// dispatcher of the stack.
	//
	// Attach is called with a nil dispatcher when the endpoint's NIC is being
	// removed.
	Attach(dispatcher NetworkDispatcher)

The NetworkDispatch interface in full is:

    type NetworkDispatcher interface {
        // DeliverNetworkPacket finds the appropriate network protocol endpoint
        // and hands the packet over for further processing.
        //
        //
        // If the link-layer has a header, the packet's link header must be populated.
        //
        // DeliverNetworkPacket may modify pkt.
        DeliverNetworkPacket(protocol tcpip.NetworkProtocolNumber, pkt *PacketBuffer)

        // DeliverLinkPacket delivers a packet to any interested packet endpoints.
        //
        // This method should be called with both incoming and outgoing packets.
        //
        // If the link-layer has a header, the packet's link header must be populated.
        DeliverLinkPacket(protocol tcpip.NetworkProtocolNumber, pkt *PacketBuffer)
    }

sniffer implements this as follows:

    // DeliverNetworkPacket implements the stack.NetworkDispatcher interface. It is
    // called by the link-layer endpoint being wrapped when a packet arrives, and
    // logs the packet before forwarding to the actual dispatcher.
    func (e *Endpoint) DeliverNetworkPacket(protocol tcpip.NetworkProtocolNumber, pkt *stack.PacketBuffer) {

Here are all the places this function is implemented:

    https://github.com/search?q=repo%3Agoogle%2Fgvisor%20DeliverNetworkPacket&type=code

One place it is implemented is nic, which is not exported but seems central:

    https://github.com/google/gvisor/blob/48b7308dcef150deacf42b62e9aea90451944946/pkg/tcpip/stack/nic.go#L163

For what it's worth here is the core implementation of socket in sentry, which intercepts all the linux syscalls in a container run by runsc. It is backed by a tcpip.Endpoint:

    https://github.com/google/gvisor/blob/48b7308dcef150deacf42b62e9aea90451944946/pkg/sentry/socket/netstack/netstack.go#L362

Even more concretely, here is the implementation fo accept(2) in sentry:

    https://github.com/google/gvisor/blob/48b7308dcef150deacf42b62e9aea90451944946/pkg/sentry/socket/unix/unix.go#L164

Sentry actually supports multiple "stacks" only one of which is tcpip.Stack. It also supports using the host network stack directly:

    https://github.com/google/gvisor/blob/48b7308dcef150deacf42b62e9aea90451944946/pkg/sentry/socket/hostinet/stack.go#L171

The general "Stack" interface is implemented in sentry/inet:

    https://github.com/google/gvisor/blob/48b7308dcef150deacf42b62e9aea90451944946/pkg/sentry/inet/inet.go#L28

The implementation for tcpip.Stack is in "netstack":

    https://github.com/google/gvisor/blob/48b7308dcef150deacf42b62e9aea90451944946/pkg/sentry/socket/netstack/stack.go#L42

Great overview of many of the low-level ways of sending out raw packets in linux:

    https://toonk.io/sending-network-packets-in-go/index.html

XDP is the latest way -- you write a packet filter in C and load it directly into the kernel! There are some examples of how to do this in gvisor:

    https://pkg.go.dev/gvisor.dev/gvisor/tools/xdp#section-readme

How to create IPv4 packets with gopacket:

    https://github.com/atoonk/go-pktgen/blob/main/pktgen/packet.go#L79

Docker desktop solves this issue by intercepting everything and accepting all TCP connections, then dynamically creating a TCP connection to real host:

    https://www.docker.com/blog/how-docker-desktop-networking-works-under-the-hood/

This is docker desktop, but what about ordinary docker daemon?

Here is a very helpful tutorial showing how to do it from scratch with veth pairs:

    https://labs.iximiuz.com/tutorials/container-networking-from-scratch

    ip netns list                           # list available network namespace
    ip netns add netns0                     # create a network namespace
    nsenter --net=/run/netns/netns0 bash    # enter a network namespace
    sudo iptables -t nat --list-rules       # list rules in the NAT table

    iptables -t nat -A POSTROUTING -s 172.18.0.0/16 ! -o br0 -j MASQUERADE      # THIS IS WHAT I NEED

    "The command is fairly simple when you know how iptables work - we added a new rule to the nat table of the POSTROUTING chain asking to masquerade all the packets originated in 172.18.0.0/16 network, except those that are going to the bridge interface."

OK so to do it with veth pairs the steps are:

    - turn on IP forwarding                                             echo 1 > /proc/sys/net/ipv4/ip_forward

    - create the namespace                                              ip netns add httptap-ns
    - create the veth pair                                              ip link add httptap-veth type veth peer name httptap-ceth
    - put one side of the veth pair into the namespace                  ip link set httptap-ceth netns httptap-ns
    - assign an IP address to the outer part of the pair                ip addr add 10.1.2.1/24 dev httptap-veth
    - bring up the out part of the pair                                 ip link set httptap-veth up
    - in the namespace, assign an IP address                            nsenter --net=/run/netns/httptap-ns ip addr add 10.1.2.50/24 dev httptap-ceth
    - in the namespace, route everything to one side of the veth pair   nsenter --net=/run/netns/httptap-ns ip route add default via 10.1.2.1
    - in the namespace, bring the device up                             nsenter --net=/run/netns/httptap-ns ip link set httptap-ceth up
    - setup NAT                                                         iptables -t nat -A POSTROUTING -s 10.1.2.0/24 ! -o httptap-veth -j MASQUERADE

    - in the namespace, ping 8.8.8.8

Doing it with bridges to allow multiple namespaces to coexist on the same network is more complex. You basically have to:

    - create bridge                                 ip link add br0 type bridge
    - activate bridge                               ip link set br0 up
    - assign the interface to the bridge            ip link set veth0 master br0
    - give the bridge an IP address                 ip addr add 172.18.0.1/16 dev br0

In his example he gave the following addresses:

    For the outer part of the veth pair:        ip addr add 172.18.0.11/16 dev veth0
    For the inner part of the ceth pair:        ip addr add 172.18.0.10/16 dev ceth0

    (For the second container outer part:       ip addr add 172.18.0.21/16 dev veth1)
    (For the second container inner part:       ip addr add 172.18.0.20/16 dev ceth1)

    For the bridge:                             ip addr add 172.18.0.1/16 dev br0

This is extremely helpful

Here is a very simple example of port forwarding using tun devices (title says its a vpn but it's not):

    https://www.nsl.cz/using-tun-tap-in-go-or-how-to-write-vpn/

Permanently turning on IP forwarding:

    echo net.ipv4.ip_forward=1 >> /etc/sysctl.d/enable-ip-forward.conf

Check whether IP forwarding is on:

    sysctl net.ipv4.ip_forward

In the end I did not get a veth pair to work correctly with iptables masquerade

# Sentry

gvisor sentry

This function execs /proc/self/exe with the boot subcommand, in a set of namespaces:

// createSandboxProcess starts the sandbox as a subprocess by running the "boot"
// command, passing in the bundle dir.
func (s *Sandbox) createSandboxProcess(conf *config.Config, args *Args, startSyncFile *os.File) error {

So look at the boot subcommand of runsc...

In the end, there is a call in runsc/boot/loader.go that starts a process like this:

	tg, _, err := l.k.CreateProcess(info.procArgs)
	if err != nil {
		return nil, nil, fmt.Errorf("creating process: %w", err)
	}

This in turn calls into pkg/sentry/kernel/kernel.go CreateProcess:

    // CreateProcess creates a new task in a new thread group with the given
    // options. The new task has no parent and is in the root PID namespace.
    //
    // If k.Start() has already been called, then the created process must be
    // started by calling kernel.StartProcess(tg).
    //
    // If k.Start() has not yet been called, then the created task will begin
    // running when k.Start() is called.
    //
    // CreateProcess has no analogue in Linux; it is used to create the initial
    // application task, as well as processes started by the control server.
    func (k *Kernel) CreateProcess(args CreateProcessArgs) (*ThreadGroup, ThreadID, error) {

The core work step in a task is this:

func (app *runApp) execute(t *Task) taskRunState {
    	...
		for _, work := range queue {
			work.TaskWork(t)
		}

In the above, queue is a []TaskWorker

NOTES.md

View HTTP/HTTPS requests made by any Linux program


  httptap

View the HTTP and HTTPS requests made by any linux program by running `httptap -- <command>`. For example, the following runs curl on "monasticacademy.org", which results in an HTTP status of 308 (Redirect):

```shell
$ httptap -- curl https://monasticacademy.org
---> GET https://monasticacademy.org/
<--- 308 https://monasticacademy.org/ (15 bytes)
```

Now let's try the same thing with an HTTP request from python. This time we see that python follows the redirect and gets a 200 OK response:

```shell
httptap -- python -c "import requests; requests.get('https://monasticacademy.org')"
---> GET https://monasticacademy.org/
<--- 308 https://monasticacademy.org/ (15 bytes)
---> GET https://www.monasticacademy.org/
<--- 200 https://www.monasticacademy.org/ (5796 bytes)
```

To run `httptap` you do not need to be the root user. You do not need to set up any kind of daemon or make any system-wide changes to your system (edit: on Ubuntu 23.10 and later you will need to run [the sysctl documented below](#ubuntu-2310-and-later)). It will not create any iptables rules or change your routing table, and generally will not affect any other processes running on the same system. The `httptap` executable is a static Go binary that runs without dependencies.

Httptap only runs on linux at present. It makes use of linux-specific system calls -- in particular network namespaces -- that will unfortunately make it very difficult to port to other operating systems. If you know how httptap could be ported to other operating systems then please get in touch!

# Install pre-built binary

```shell
curl -L https://github.com/monasticacademy/httptap/releases/latest/download/httptap_linux_$(uname -m).tar.gz | tar xzf -
```

For all versions and CPU architectures see the [latest releases page](https://github.com/monasticacademy/httptap/releases/latest).

# Install with Go

```shell
go install github.com/monasticacademy/httptap@latest
```

# Ubuntu 23.10 and later

On Ubuntu 23.10 and later you will need to run the following in order to use httptap:

```shell
sudo sysctl -w kernel.apparmor_restrict_unprivileged_unconfined=0
sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0
```

What this does is disable a [recent kernel feature that restricts unpriveleged user namespaces](https://ubuntu.com/blog/ubuntu-23-10-restricted-unprivileged-user-namespaces). The above may also be needed on other distros that have disabled unpriveleged user namespaces by default. I will update this documentation as I learn more. I am investigating ways to avoid the need for this entirely by shipping an apparmor profile with httptap.

# Quickstart

Let's run a simple test:

```shell
httptap -- curl -s https://buddhismforai.sutra.co -o /dev/null
---> GET https://buddhismforai.sutra.co/
<--- 302 https://buddhismforai.sutra.co/ (117 bytes)
```

What happened here is that we ran `curl -s https://buddhismforai.sutra.co -o /dev/null` and it received a 302 redirect from the server. `httptap` printed summaries of the HTTP requests and their responses. Let's see how it changes if we tell curl to follow redirects by adding `-L`:

```shell
httptap -- curl -sL https://buddhismforai.sutra.co -o /dev/null
---> GET https://buddhismforai.sutra.co/
<--- 302 https://buddhismforai.sutra.co/ (117 bytes)
---> GET https://buddhismforai.sutra.co/space/cbodvy/content
<--- 200 https://buddhismforai.sutra.co/space/cbodvy/content (6377 bytes)
```

Now we can see that after receiving the 302 redirect, curl made an additional HTTP request to the URL to which it was redirected, which is what you expect when using `-L` with curl.

Let's see what HTTP endpoints the Google Cloud command line interface uses to list compute resources (this requires that you have gcloud installed and are signed in):

```shell
$ httptap -- gcloud compute instances list
---> POST https://oauth2.googleapis.com/token
<--- 200 https://oauth2.googleapis.com/token (997 bytes)
---> GET https://compute.googleapis.com/compute/v1/projects/maple-public-website/aggregated/instances?alt=json&includeAllScopes=True&maxResults=500&returnPartialSuccess=True
<--- 200 https://compute.googleapis.com/compute/v1/projects/maple-public-website/aggregated/instances?alt=json&includeAllScopes=True&maxResults=500&returnPartialSuccess=True (19921 bytes)
NAME       ZONE        MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP     STATUS
<your cloud instances listed here>
```

What happened here is that we ran `gcloud compute instances list`, which lists the compute instances that the signed-in user has on Google Cloud. The bottom two lines of output were printed by `gcloud`; the rest were printed by `httptap` and show what HTTP requests `gcloud` used to get the information it printed.

Let's see what HTTP endpoints kubectl uses in a "get all" (this requires that you have kubectl installed and are authenticated to a cluster):

```shell
$ httptap --https 443 6443 -- kubectl get all --insecure-skip-tls-verify
---> GET https://cluster:6443/api/v1/namespaces/default/pods?limit=500
<--- 200 https://cluster:6443/api/v1/namespaces/default/pods?limit=500 (38345 bytes)
---> GET https://cluster:6443/api/v1/namespaces/default/replicationcontrollers?limit=500
<--- 200 https://cluster:6443/api/v1/namespaces/default/replicationcontrollers?limit=500 (2509 bytes)
---> GET https://cluster:6443/api/v1/namespaces/default/services?limit=500
<--- 200 https://cluster:6443/api/v1/namespaces/default/services?limit=500 (5586 bytes)
---> GET https://cluster:6443/apis/apps/v1/namespaces/default/daemonsets?limit=500
<--- 200 https://cluster:6443/apis/apps/v1/namespaces/default/daemonsets?limit=500 (3052 bytes)
---> GET https://cluster:6443/apis/apps/v1/namespaces/default/deployments?limit=500
<--- 200 https://cluster:6443/apis/apps/v1/namespaces/default/deployments?limit=500 (7438 bytes)
---> GET https://cluster:6443/apis/apps/v1/namespaces/default/replicasets?limit=500
<--- 200 https://cluster:6443/apis/apps/v1/namespaces/default/replicasets?limit=500 (47211 bytes)
---> GET https://cluster:6443/apis/apps/v1/namespaces/default/statefulsets?limit=500
<--- 200 https://cluster:6443/apis/apps/v1/namespaces/default/statefulsets?limit=500 (1416 bytes)
---> GET https://cluster:6443/apis/autoscaling/v2/namespaces/default/horizontalpodautoscalers?limit=500
<--- 200 https://cluster:6443/apis/autoscaling/v2/namespaces/default/horizontalpodautoscalers?limit=500 (2668 bytes)
---> GET https://cluster:6443/apis/batch/v1/namespaces/default/cronjobs?limit=500
<--- 200 https://cluster:6443/apis/batch/v1/namespaces/default/cronjobs?limit=500 (3134 bytes)
---> GET https://cluster:6443/apis/batch/v1/namespaces/default/jobs?limit=500
<--- 200 https://cluster:6443/apis/batch/v1/namespaces/default/jobs?limit=500 (2052 bytes)
<ordinary kubectl output here>
```

In the above, `--insecure-skip-tls-verify` is necessary because kubectl doesn't use the httptap-generated certificate authority, and `--https 443 6443` says to treat TCP connections on ports 443 and 6443 as HTTPS connections, which is needed because my cluter's API endpoint uses port 6443.

Let's see how DNS-over-HTTP works when you use `--doh-url` with curl:

```shell
$ httptap -- curl -sL --doh-url https://cloudflare-dns.com/dns-query https://buddhismforai.sutra.co -o /dev/null
---> POST https://cloudflare-dns.com/dns-query
<--- 200 https://cloudflare-dns.com/dns-query (149 bytes)
---> POST https://cloudflare-dns.com/dns-query
<--- 200 https://cloudflare-dns.com/dns-query (150 bytes)
---> GET https://buddhismforai.sutra.co/
<--- 302 https://buddhismforai.sutra.co/ (117 bytes)
---> GET https://buddhismforai.sutra.co/space/cbodvy/content
<--- 200 https://buddhismforai.sutra.co/space/cbodvy/content (6377 bytes)
```

What happened here is that we told `curl` to request the url "https://buddhismforai.sutra.co", using the cloudflare DNS-over-HTTP service at `cloudflare-dns.com`. In the output we see that `curl` made 4 HTTP requests in total; the first two were DNS lookups, and then the second two were the ordinary HTTP requests for buddhismforai.sutra.co.

Let's print the contents of the DNS-over-HTTP payloads:

```shell
$ httptap --head --body -- curl -sL --doh-url https://cloudflare-dns.com/dns-query https://buddhismforai.sutra.co -o /dev/null
---> POST https://cloudflare-dns.com/dns-query
> Accept: */*
> Content-Type: application/dns-message
> Content-Length: 40
buddhismforaisutraco
<--- 200 https://cloudflare-dns.com/dns-query (149 bytes)
< Alt-Svc: h3=":443"; ma=86400
< Server: cloudflare
< Date: Tue, 24 Dec 2024 18:13:12 GMT
< Content-Type: application/dns-message
< Access-Control-Allow-Origin: *
< Content-Length: 149
< Cf-Ray: 8f7290631e334211-EWR
buddhismforaisutraco�
��w�4+#G�.           <wildcardsutraco	herokudnscom�4+!�=�4+
...
```

Here the `--head` option tells httptap to print the HTTP headers, and `--body` tells it to print the raw HTTP payloads. To keep it short I'm showing just the first request/response pair.

# HAR output

You can dump the HTTP requests and responses to a HAR file like this:

```
$ httptap --dump-har out.har -- curl -Lso /dev/null https://monasticacademy.org
```

There are many HAR viewers out there that can visualize this dump file. For example here is how the above looks in the [Google HAR Analyzer](https://toolbox.googleapps.com/apps/har_analyzer/):

![HAR Analyzer Screenshot](docs/har-screenshot.png)

Again, what you're looking at here is one HTTP request to https://monasticacademy.org that returns a 308 Redirect, followed by a second HTTP request to https://www.monasticacademy.org that return a 200 OK.

# Reaching localhost

To reach a localhost port, replace "localhost" with "host.httptap.local" or the special IP address 169.254.77.65. Traffic to these destinations will routed to localhost on your machine.

The situation here is that in linux every network namespace automatically gets its own loopback device (127.0.0.1), and these can't be shared. This means that if a process running within httptap tries to connect to 127.0.0.1:1234, it'll actually be connecting to a "different" 127.0.0.1 from another process on your machine listening on this same address and port, and you won't be able to connect.

As a workaround, the address 169.254.77.65 is hardcoded within httptap to route to 127.0.0.1.

# How it works

When you run `httptap -- <command>`, httptap runs `<command>` in an isolated network namespace, injecting a certificate authority created on-the-fly in order to decrypt HTTPS traffic. Here is the process in detail:

In linux, there is a kernel API for creating and configuring network interfaces. Conventionally, a network interface would be a physical ethernet or WiFi controller in your computer, but it is possible to create a special kind of network interface called a TUN device. A TUN device shows up to the system in the way that any network interface shows up, but any traffic written to it will be delivered to a file descriptor held by the process that created it. Httptap creates a TUN device and runs the subprocess in an environment in which all network traffic is routed through that device.

There is also a kernel API in linux for creating network namespaces. A network namespace is a list of network interfaces and routing rules. When a process is started in linux, it can be run in a specified network namespace. By default, processes run in a root network namespace that we do not want to make chagnes to because doing so would affect all network traffic on the system. Instead, we create a network namespace in which there are only two network interfaces: a loopback device (127.0.0.1) and a TUN device that delivers traffic to us. Then we run the subprocess in that namespace.

The traffic from the network device is delivered to us as raw IP packets. We must parse the IP packets as well as the inner TCP and UDP packets, and write raw IP packets back to the subprocess. This requires a software implementation of the TCP/IP protocol, which is by far the most difficult part of httptap. The TCP/IP implementation in httptap is missing many aspects of the full TCP protocol, but still works reasonably well for its purpose.

Suppose the subprocess makes an HTTP request to www.example.com. The first thing we receive is a TCP SYN packet addressed to 93.184.215.14 (the current IP address of example.com). We respond with a SYN+ACK packet with source address 93.184.215.14, though in truth the packet did not come from 93.184.215.14, but from us. Separately, we establish our own TCP connection to 93.184.215.14 using the ordinary sockets API in the linux kernel. When the subprocess sends data to 93.184.215.14 we relay it over our separate TCP connection, and vice versa for return data. This is a traditional transparent TCP proxy, and in this way we can view all data flowing to and from the subprocess, though we won't be able to decrypt HTTPS traffic without a bit more work.

When a client makes an HTTPS request, it asks the server for evidence that it is who it says it is. If the server has a certificate signed by a certificate authority, it can use that certificate to prove that it is who it says it is. The client will only accept such a certificate if it trusts the certificate authority that signed the certificate. Operating systems, web browsers, and many other pieces of software come with a list of a few hundred certificate authorities that they trust. Many of these pieces of software have ways for users to add additional certificate authorities to this list. We make use of this.

When httptap starts, it creates a certificate authority (actually a private key plus a corresponding x509 certificate), writes it to a file on the filesystem visible only to the subprocess, and sets a few environment variables -- again only visible to the subprocess being run -- that add this certificate authority to the list of trusted certificate authorities. Since the subprocess trusts this certificate authority, and httptap holds the private key for the certificate authority, it can prove to the subprocess that it is the server which which the subprocess was trying to communicate. In this way we can read the plaintext HTTP requests.

# How it was made

Httptap is part of an experiment in developing technology in the context of Buddhist monasticism. It was developed at the [Monastic Academy](https://www.monasticacademy.org) in Vermont in the US. We believe that a monastic schedule, and the practice of the Buddhist spiritual path more generally, provide ideal conditions for technological development. The way we have set things up is that we live and practice together on a bit over a hundred acres of land. In the mornings and evenings we chant and meditate together, and for about one week out of every month we run and participate in a meditation retreat. The rest of the time we work together on everything from caring for the land, maintaining the buildings, cooking, cleaning, planning, fundraising, and for the past few years developing software together. This project is a demonstration of what is possible on the software side, but of course to see the full product of our work you should come visit us.

If you're interested, we run an [AI fellowship program](https://www.monasticacademy.org/ai-fellowship), which is a funded month-to-month program where you live on the land, participate in the schedule, and do your own work during the day. We also have a 3-month [monastic training program](https://www.monasticacademy.org/train), which can lead into our long-term residential training.

For the past few years we have been recording a lecture series called [Buddhism for AI](https://buddhismforai.sutra.co). It's about our efforts to design a religion (yes, a religion) based on Buddhism for consumption directly by AI systems. We actually feel this is very important work given the world situation.

Finally, our head teacher [Soryu Forall](https://www.monasticacademy.org/teacher) published a book a few years back called [Buddhism For All](https://buddhism.net/buddhism-for-all-book/). We're working on a sequel at the moment.

![MAPLE Group Photo](docs/group.webp)

# Caveats

- The process cannot listen for incoming network connections
- You need access to `/dev/net/tun`
- All ICMP echo requests will be echoed without sending any ICMP packets out to the real network

# Donations

You can support [me personally through github sponsors](https://github.com/sponsors/alexflint), or (my preference if it's an option for you) [the community I live in through our donate page](https://www.monasticacademy.org/donate).

README.md


This is a DNS proxy that answers simple questions using Go's built-in resolver, which reads nsswitch.conf and resolv.conf and does a bunch of work to be as much like  gethostbyname, or even use gethostbyname when available via cgo.


See https://github.com/xjasonlyu/tun2socks/blob/main/core/tcp.go#L78

I may be able to use tun2socks off-the-shelf. The core piece is very nicely designed:
  https://github.com/xjasonlyu/tun2socks/blob/main/engine/engine.go#L227-L234

I should be able to use both the tunnel _and_ the proxy from tun2socks. I'll probably always use the Direct proxy.

What I need to do is implement proxy.Dialer:

    type Dialer interface {
        DialContext(context.Context, *M.Metadata) (net.Conn, error)
        DialUDP(*M.Metadata) (net.PacketConn, error)
    }

    https://github.com/xjasonlyu/tun2socks/blob/main/proxy/proxy.go#L19-L22

and pass it in, ultimate to core.CreateStack in Config.TransportHandler:

    https://github.com/xjasonlyu/tun2socks/blob/main/core/stack.go#L25

but more specifically, the dialer goes into the tunnel via SetDialer:

	tunnel.T().SetDialer(_defaultProxy)

    https://github.com/xjasonlyu/tun2socks/blob/main/engine/engine.go#L195

and then the tunnel is the TransportHandler:

    stack, err = core.CreateStack(&core.Config{
        LinkEndpoint:     _defaultDevice,
        TransportHandler: tunnel.T(),
        MulticastGroups:  multicastGroups,
        Options:          opts,
    });

    https://github.com/xjasonlyu/tun2socks/blob/main/engine/engine.go#L227-L234


Forked from https://github.com/vvakame/go-harlog

net/http client logging by HAR format.

Take http request/response log by HAR (HTTP Archive) format.
It can visualize by [any](https://developers.google.com/web/updates/2017/08/devtools-release-notes#har-imports) [tools](https://toolbox.googleapps.com/apps/har_analyzer/).

## How to use

```shell script
$ go get github.com/vvakame/go-harlog
```

```go
har := &harlog.Transport{}
hc := &http.Client{
    Transport: har,
}

// do something...

b, err := json.MarshalIndent(har.HAR(), "", "  ")
if err != nil {
    return err
}
fmt.Println(string(b))
```

See HAR file in Google Chrome DevTools.

This screenshots are generated by this library.
Capture the log about Google Cloud Storage access by [cloud.google.com/go/storage](https://godoc.org/cloud.google.com/go/storage).

![Headers](https://user-images.githubusercontent.com/125332/65957276-60f68f80-e487-11e9-86e4-dfcc5fe64f44.png)

![Response](https://user-images.githubusercontent.com/125332/65957297-6c49bb00-e487-11e9-8762-2c176cacc83a.png)

![Timing](https://user-images.githubusercontent.com/125332/65957313-779ce680-e487-11e9-9c00-f03c257b2ef3.png)

## Limitations

* compressed response is not supported yet.
* `headersSize` is not calculated.

patches welcome!


# 🚀 Welcome to 21st.dev!

**[21st.dev](https://21st.dev)** is your go-to open-source community registry for **React UI components**! Whether you're a developer, designer, or just someone who loves building beautiful interfaces, 21st.dev is the place to **publish, discover, and install** minimal, modern, and reusable React components powered by **Tailwind CSS** and **Radix UI**.

Inspired by the amazing [shadcn/ui](https://ui.shadcn.com/), we're here to make building UIs faster, easier, and more fun. 🎉

[![Discord](https://img.shields.io/badge/Discord-Join%20Us-7289da?logo=discord&logoColor=white&style=for-the-badge)](https://discord.gg/Qx4rFunHfm)

---

## 👥 Community

We're building more than just a component registry – we're building a community of developers who love creating beautiful UIs. Here's how you can get involved:

- **Join our [Discord](https://discord.gg/Qx4rFunHfm)** – Get help, share your work, and chat with other developers
- **Follow us on [X/Twitter](https://x.com/serafimcloud)** – Stay updated with the latest features and components
- **Star us on [GitHub](https://github.com/serafimcloud/21st)** – Support the project and follow our progress
- **Share your components** – Help others by contributing your UI components
- **Give feedback** – Your input shapes the future of 21st.dev

---

## 🌟 Why 21st.dev?

- **Open Source & Community-Driven**: Built by developers, for developers. Everyone is welcome to contribute!
- **Minimal & Modern**: Components are lightweight, customizable, and designed with Tailwind and Radix UI.
- **Easy to Use**: Install any component with a single `npx shadcn` command.
- **Multiple Demos**: Each component can have multiple demos with previews and videos.
- **Extensible**: Add your own components, themes, and dependencies effortlessly.
- **TypeScript First**: Full type support out of the box.

---

## 🛠 Publish Your Component in 1 Minute!

Yes, you read that right—**1 minute**! 🕒
Publishing your React component is as easy as pie. Just head over to our [publish page](https://21st.dev) and share your creation with the world.

### Review Process

When you publish a component, it follows this journey:

1. **Initial State** (`on_review`) - Component is available via direct link and awaiting review
2. **Posted State** (`posted`) - Component has passed review and is available on your profile and via direct link
3. **Featured State** (`featured`) - Component is featured on the homepage and in public listings

I ([Serafim](https://x.com/serafimcloud)) personally review each component to ensure it meets our quality standards before featuring it.

### Quality Guidelines

To get your component featured, ensure it follows these key principles:

1. **Visual Quality**

   - Component should be visually polished and provide real value to the community
   - Follow modern UI/UX practices

2. **Code Structure**

   - Follow the shadcn/ui pattern of separating component logic from demo content
   - Component file should contain only the reusable functionality
   - Demo file should showcase the component through props, not hardcoded content

3. **Theming**
   - Use CSS variables from shadcn's theme system (see `globals.css`)
   - Support both light and dark modes out of the box
   - Use the proper color variables (e.g., `hsl(var(--background))`)

Remember: Quality over quantity! We prioritize well-crafted, reusable components that follow these guidelines.

### File Structure:

```
your-component/                # How to organize your files
├── code.tsx                  # Main component
├── tailwind.config.js        # Optional Tailwind config
├── globals.css              # Optional global styles
└── demos/                    # Each component can have multiple demos
    ├── default/             # Primary demo (required)
    │   ├── code.demo.tsx    # Demo implementation
    │   ├── preview.png      # Static preview image
    │   └── video.mp4        # Optional demo video
    └── advanced/            # Additional demos (optional)
        ├── code.demo.tsx
        ├── preview.png
        └── video.mp4

# Files are stored in Cloudflare R2 under:
# components-code/{user_id}/{component_slug}/...
```

### What We Support:

- **Pure React Components** – Build with React, no fuss.
- **Next.js Client Components** – We've got you covered (server-side rendering coming soon!).
- **TypeScript** – Because type safety is ❤.
- **Tailwind Themes** – Customize to your heart's content.
- **Global CSS Styles** – Add your own flair.
- **Radix UI** – Accessible and unstyled primitives.
- **Any npm Dependencies** – Thanks to [Sandpack](https://sandpack.codesandbox.io/).
- **Internal Dependencies** – Use any component from our registry as a dependency.
- **Multiple Demos** – Showcase different use cases and variations.
- **Preview Images & Videos** – Make your component shine.

**Pro Tip**: We encourage TypeScript components. JavaScript is cool too, but untested for now. 😉

---

## ⚡ Install a Component in Seconds!

Found a component you love on [21st.dev](https://21st.dev)? Installing it is a breeze. Just copy the `npx shadcn` command and run it in your project's root folder.

For example, to install the `shadcn/ui/accordion` component, run:

```bash
npx shadcn@latest add "https://21st.dev/r/shadcn/accordion"
```

This command will:

- Create all necessary files for the component and its dependencies.
- Extend your Tailwind theme automatically.
- Set up any required global styles.

**Why use the command?**
While you can copy-paste code directly from the website, using `npx shadcn` ensures you get all the files and dependencies without missing a beat. It's the recommended way to go! 🚀

---

## 🏗 Architecture

The project uses a modern stack:

- **Frontend**: Next.js 14
- **Database**: Supabase for metadata and user data
- **Authentication**: Clerk
- **File Storage**: Cloudflare R2
- **Analytics**: Amplitude

---

## 🛠 Contributing to 21st.dev

We're thrilled you want to contribute! Whether you're a seasoned developer or just starting out, there's a place for you here. Let's get you set up:

### 🛠 Prerequisites

Before diving in, make sure you have:

- A **Supabase** account
- A **Clerk** account
- A **Cloudflare R2** account

### 🚀 Setup Guide

1. **Fork & Clone**: Fork the repository and clone it locally. We recommend using [Cursor](https://cursor.com) if you're non-technical.

2. **Install Dependencies**: We're big fans of `pnpm`! Run:

   ```bash
   pnpm install
   ```

3. **Environment Setup**: Create a `.env.local` in `apps/web` with:

   ```
   # Supabase
   NEXT_PUBLIC_SUPABASE_URL=https://*****
   NEXT_PUBLIC_SUPABASE_KEY=*****
   SUPABASE_SERVICE_ROLE_KEY=*****

   # Clerk
   NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=*****
   CLERK_SECRET_KEY=*****
   CLERK_WEBHOOK_SECRET=*****

   # Cloudflare R2
   NEXT_PUBLIC_CDN_URL=https://*****
   R2_ACCESS_KEY_ID=*****
   R2_SECRET_ACCESS_KEY=*****
   NEXT_PUBLIC_R2_ENDPOINT=https://*****

   # Other
   NEXT_PUBLIC_APP_URL=https://21st.dev
   NEXT_PUBLIC_AMPLITUDE_API_KEY=*****
   ```

4. **Start Development**:

   ```bash
   pnpm dev
   ```

5. **Open a PR**: Once you're done, open a PR to the `main` branch. We can't wait to see what you've built! 🎉

---

## 👥 Team

The project was developed by [@serafimcloud](https://x.com/serafimcloud), with significant contributions from [@daniel_dhawan](https://x.com/daniel_dhawan) and [@garrrikkotua](https://x.com/garrrikkotua).

---

## 🙏 Acknowledgments

This project wouldn't be possible without the incredible work of:

- [shadcn/ui](https://ui.shadcn.com/)
- [Tailwind CSS](https://tailwindui.com/)
- [Sandpack by CodeSandbox](https://sandpack.codesandbox.io/)
- [Supabase](https://supabase.com)
- [Vercel](https://vercel.com)
- [Clerk](https://clerk.com)
- [Cloudflare](https://cloudflare.com)
- [Cursor](https://cursor.com)
- [Claude 3.5 Sonnet by Anthropic](https://anthropic.com/)
- [MagicUI](https://magicui.design)

And, of course, **YOU**—our amazing open-source contributors! ❤

---

## 🚀 Let's Build the Future Together!

Ready to dive in? Start exploring, publishing, and contributing today. Let's make 21st.dev the best place for React UI components on the web. Happy coding! 🎉

## 📋 Component Guidelines

We maintain high quality standards for components that appear on the homepage and in public listings. While all published components are immediately available via direct links, they go through a review process before being featured publicly.

### Review Process

When you publish a component, it follows this journey:

1. **Initial State** (`on_review`) - Component is available via direct link and awaiting review
2. **Posted State** (`posted`) - Component has passed review and is available on your profile and via direct link
3. **Featured State** (`featured`) - Component is featured on the homepage and in public listings

I ([Serafim](https://x.com/serafimcloud)) personally review each component to ensure it meets our quality standards before featuring it. This helps maintain a high-quality collection of components that truly benefit the community.

### Quality Standards

To ensure your component gets featured, follow these guidelines:

1. **Visual Design**

   - Component should be visually polished and provide value to the community
   - Follow modern UI/UX practices
   - Support both light and dark themes
   - Use consistent spacing and sizing

2. **Code Structure**

   - Follow the shadcn/ui pattern of separating component logic from demo content
   - Component file should contain only the reusable functionality
   - Demo file should showcase the component with realistic content
   - Use props for customization and content injection

3. **Theming**

   - Use CSS variables from shadcn's theme system (see `globals.css`)
   - Support both light and dark modes out of the box
   - Use `hsl` variables for colors (e.g., `hsl(var(--background))`)
   - Follow the naming convention for CSS variables

4. **Accessibility**

   - Include proper ARIA attributes
   - Support keyboard navigation
   - Maintain sufficient color contrast
   - Test with screen readers

5. **Documentation**

   - Provide clear prop documentation
   - Include usage examples
   - Document any required dependencies
   - Add helpful comments for complex logic

6. **Best Practices**
   - Keep components focused and single-purpose
   - Minimize external dependencies
   - Ensure responsive behavior
   - Follow TypeScript best practices
   - Include meaningful default props

Remember: Quality over quantity! We'd rather have fewer, well-crafted components than many that don't meet our standards.

---

README.md

npm for design engineers: largest marketplace of shadcn/ui-based React Tailwind components, blocks and hooks


This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/create-next-app).

## Getting Started

First, run the development server:

```bash
npm run dev
# or
yarn dev
# or
pnpm dev
# or
bun dev
```

Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.

You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.

This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load Inter, a custom Google Font.

## Learn More

To learn more about Next.js, take a look at the following resources:

- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.

You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!

## Deploy on Vercel

The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.

Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.


# `@turbo/eslint-config`

Collection of internal eslint configurations.


# Contributing

**IMPORTANT:** This project only accepts contributions based on [lucide icons](https://lucide.dev/). Pull requests containing custom icons or icons from other icon packs will be closed.

We welcome contributions to our project! Please follow these steps to contribute:

1. Fork the repository on GitHub.

2. Clone your forked repository to your local machine:

   ```
   git clone https://github.com/your-username/icons.git
   ```

3. Navigate to the project directory:

   ```
   cd icons
   ```

4. Create a new branch for your feature or bug fix:

   ```
   git checkout -b your-branch-name
   ```

5. Install the project dependencies:

   ```
   yarn install
   ```

6. Make your changes to the codebase.

7. Build the project:

   ```
   yarn build
   ```

8. Test the application to ensure your changes work as expected:

   ```
   yarn lint
   yarn build
   yarn gen-cli
   ```

9. Commit your changes:

   ```
   git commit -m "Your commit message"
   ```

10. Push your changes to your fork:

    ```
    git push origin your-branch-name
    ```

11. Open a pull request on the original repository.

Thank you for contributing to our project!

CONTRIBUTING.md

beautifully crafted animated icons


## `pqoqubbw/icons` is beautifully crafted animated icons.

**Demo** → [icons.pqoqubbw.dev](https://icons.pqoqubbw.dev)

### Svelte icons: [movingicons.dev](https://www.movingicons.dev/) by [@jis3r](https://github.com/jis3r)
### Vue icons: [imfenghuang.github.io/icons](https://imfenghuang.github.io/icons/) by [@imfenghuang](https://github.com/imfenghuang)

![preview](./app/og.png)

## Contributing

We welcome contributions to `pqoqubbw/icons`! Please read our [contributing guidelines](CONTRIBUTING.md) on how to submit improvements and new icons.

## Terms of Use

Feel free to use these components in personal and commercial projects. However, while the tutorials and demos are available for your use as-is, they cannot be redistributed or resold. Let’s keep things fair and respect each other’s work.

If you have any questions or just want to say hi, feel free to reach out to me on X 👉 [@pqoqubbw](https://x.com/pqoqubbw).

## Notes

This project is a work in progress, and i'm continuously working to improve and expand this collection. I’d love to hear your feedback or see your contributions as the project evolves!

README.md

beautifully crafted animated icons


## I have read the [CONTRIBUTING.md](https://github.com/pqoqubbw/icons/blob/main/CONTRIBUTING.md) file.

YES/NO

## I have run `yarn gen-cli` to generate the necessary files

YES/NO

## What kind of change does this PR introduce?

Bug fix, feature, docs update, ...

## What is the new behavior?

Feel free to include screenshots if it includes visual changes.

## Demo

Please attach a short video demo of the changes.

## Additional context

Add any other context or screenshots.

.github/pull_request_template.md

beautifully crafted animated icons


Steel

    The open-source browser API for AI agents & apps.

    The best way to build live web agents and browser automation tools.

[![Commit Activity](https://img.shields.io/github/commit-activity/m/steel-dev/steel-browser?color=yellow)](https://github.com/steel-dev/steel-browser/commits/main)
[![License](https://img.shields.io/github/license/steel-dev/steel-browser?color=yellow)](https://github.com/steel-dev/steel-browser/blob/main/LICENSE)
[![Discord](https://img.shields.io/discord/1285696350117167226?label=discord)](https://discord.gg/steel-dev)
[![Twitter Follow](https://img.shields.io/twitter/follow/steeldotdev)](https://twitter.com/steeldotdev)
[![GitHub stars](https://img.shields.io/github/stars/steel-dev/steel-browser)](https://github.com/steel-dev/steel-browser)

      Get Started
    ·

      Documentation
    ·

      Website
   ·

      Cookbook

## ✨ Highlights

[Steel.dev](https://steel.dev) is an open-source browser API that makes it easy to build AI apps and agents that interact with the web. Instead of building automation infrastructure from scratch, you can focus on your AI application while Steel handles the complexity.

**This repo is the core building block behind Steel - a production-ready, containerized browser sandbox that you can deploy anywhere.** It includes built-in stealth capabilities, text-to-markdown, session management, a web UI to view/debug sessions, and full browser control through standard automation frameworks like Puppeteer, Playwright, and Selenium.

Under the hood, it manages sessions, pages, and browser processes, allowing you to perform complex browsing tasks programmatically without any of the headaches:
- **Full Browser Control**: Uses Puppeteer and CDP for complete control over Chrome instances -- allowing you to connect using Puppeteer, Playwright, or Selenium.
- **Session Management**: Maintains browser state, cookies, and local storage across requests
- **Proxy Support**: Built-in proxy chain management for IP rotation
- **Extension Support**: Load custom Chrome extensions for enhanced functionality
- **Debugging Tools**: Built-in request logging and session recording capabilities
- **Anti-Detection**: Includes stealth plugins and fingerprint management
- **Resource Management**: Automatic cleanup and browser lifecycle management
- **Browser Tools**: Exposes APIs to quick convert pages to markdown, readability, screenshots, or PDFs.

For detailed API documentation and examples, check out our [API reference](https://docs.steel.dev/api-reference) or explore the Swagger UI directly at `http://0.0.0.0:3000/documentation`.

> Steel is in public beta and evolving every day. Your suggestions, ideas, and reported bugs help us immensely. Do not hesitate to join in the conversation on [Discord](https://discord.gg/steel-dev) or raise a GitHub issue. We read everything, respond to most, and love you.

If you love open-source, AI, and dev tools, [we're hiring across the stack](https://steel-dev.notion.site/jobs-at-steel?pvs=74)!

### Make sure to give us a star ⭐

## 🛠 Getting Started
The easiest way to get started with Steel is by creating a [Steel Cloud](https://app.steel.dev) account. Otherwise, you can deploy this Steel browser instance to a cloud provider or run it locally.

## ⚡ Quick Deploy
If you're looking to deploy to a cloud provider, we've got you covered.

| Deployment methods | Link                                                                                |
| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Pre-built Docker Image (API only) | [![Deploy with Github Container Redistry](https://img.shields.io/badge/GHCR-478CFF?style=for-the-badge&labelColor=478CFF&logo=github&logoColor=white)](https://github.com/steel-dev/steel-browser/pkgs/container/steel-browser-api) |
| 1-click deploy to Railway | [![Deploy on Railway](https://img.shields.io/badge/Railway-B039CB?style=for-the-badge&labelColor=B039CB&logo=railway&logoColor=white)](https://railway.app/template/FQG9Ca) |
| 1-click deploy to Render | [![Deploy to Render](https://img.shields.io/badge/Render-8A05FF?style=for-the-badge&labelColor=8A05FF&logo=render&logoColor=white)](https://render.com/deploy?repo=https://github.com/steel-dev/steel-browser) |

## 💻 Running Locally

### Docker

The simplest way to run a Steel browser instance locally is to run the pre-built Docker images:

```bash
# Clone and build the Docker image
git clone https://github.com/steel-dev/steel-browser
cd steel-browser
docker compose up
```

This will start the Steel server on port 3000 (http://localhost:3000) and the UI on port 5173 (http://localhost:5173).

You can now create sessions, scrape pages, take screenshots, and more. Jump to the [Usage](#usage) section for some quick examples on how you can do that.

## Quickstart for Contributors
When developing locally, you will need to run the [`docker-compose.dev.yml`](./docker-compose.dev.yml) file instead of the default [`docker-compose.yml`](./docker-compose.yml) file so that your local changes are reflected. Doing this will build the Docker images from the [`api`](./api) and [`ui`](./ui) directories and run the server and UI on port 3000 and 5173 respectively.

```bash
docker compose -f docker-compose.dev.yml up
```

You will also need to run it with `--build` to ensure the Docker images are re-built every time you make changes:

```bash
docker compose -f docker-compose.dev.yml up --build
```

In case you run on a custom host, you need to copy .env.example to .env while changing the host or modify the environment variables used by the `docker-compose.dev.yml` to use your host.

### Node.js
Alternatively, if you have Node.js and Chrome installed, you can run the server directly:

```bash
npm install
npm run dev
```

This will also start the Steel server on port 3000 and the UI on port 5173.

Make sure you have the Chrome executable installed and in one of these paths:

- **Linux**:
  `/usr/bin/google-chrome`

- **MacOS**:
  `/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`

- **Windows**:
  - `C:\Program Files\Google\Chrome\Application\chrome.exe` OR
  - `C:\Program Files (x86)\Google\Chrome\Application\chrome.exe`

#### Custom Chrome Executable

If you have a custom Chrome executable or a different path, you can set the `CHROME_EXECUTABLE_PATH` environment variable to the path of your Chrome executable:

```bash
export CHROME_EXECUTABLE_PATH=/path/to/your/chrome
npm run dev
```

For more details on where this is checked look at [`api/src/utils/browser.ts`](./api/src/utils/browser.ts).

## 🏄🏽♂ Usage
> If you're looking for quick examples on how to use Steel, check out the [Cookbook](https://github.com/steel-dev/steel-cookbook).
>
> Alternatively you can play with the [REPL package](./repl/README.md) too `cd repl` and `npm run start`

There are two main ways to interact with the Steel browser API:
1. [Using Sessions](#sessions)
2. [Using the Quick Actions Endpoints](#quick-actions-api)

In these examples, we assume your custom Steel API endpoint is `http://localhost:3000`.

The full REST API documentation can be found on your Steel instance at `/documentation` (e.g., `http://localhost:3000/documentation`).

#### Using the SDKs
If you prefer to use the our Python and Node SDKs, you can install the `steel-sdk` package for Node or Python.

These SDKs are built on top of the REST API and provide a more convenient way to interact with the Steel browser API. They are fully typed, and are compatible with both Steel Cloud and self-hosted Steel instances (changeable using the `baseUrl` option on Node and `base_url` on Python).

For more details on installing and using the SDKs, please see the [Node SDK Reference](https://docs.steel.dev/overview/reference/node-sdk-reference) and the [Python SDK Reference](https://docs.steel.dev/overview/reference/python-sdk-reference).

### Sessions
The `/sessions` endpoint lets you relaunch the browser with custom options or extensions (e.g. with a custom proxy) and also reset the browser state. Perfect for complex, stateful workflows that need fine-grained control.

Once you have a session, you can use the session ID or the root URL to interact with the browser. To do this, you will need to use Puppeteer or Playwright. You can find some examples of how to use Puppeteer and Playwright with Steel in the docs below:
* [Puppeteer Integration](https://docs.steel.dev/overview/guides/connect-with-puppeteer)
* [Playwright with Node](https://docs.steel.dev/overview/guides/connect-with-playwright-node)
* [Playwright with Python](https://docs.steel.dev/overview/guides/connect-with-playwright-python)

Creating a Session using the Node SDK

```typescript
import Steel from 'steel-sdk';

const client = new Steel({
  baseUrl: "http://localhost:3000", // Custom API Base URL override
});

(async () => {
  try {
    // Create a new browser session with custom options
    const session = await client.sessions.create({
      sessionTimeout: 1800000, // 30 minutes
      blockAds: true,
    });
    console.log("Created session with ID:", session.id);
  } catch (error) {
    console.error("Error creating session:", error);
  }
})();
````

Creating a Session using the Python SDK

````python
import os
from steel import Steel

client = Steel(
    base_url="http://localhost:3000",  # Custom API Base URL override
)

try:
    # Create a new browser session with custom options
    session = client.sessions.create(
        session_timeout=1800000,  # 30 minutes
        block_ads=True,
    )
    print("Created session with ID:", session.id)
except Exception as e:
    print("Error creating session:", e)
````

Creating a Session using Curl

```bash
# Launch a new browser session
curl -X POST http://localhost:3000/v1/sessions \
  -H "Content-Type: application/json" \
  -d '{
    "options": {
      "proxy": "user:pass@host:port",
      // Custom launch options
    }
  }'
```

#### Selenium Sessions
>**Note:** This integration does not support all the features of the CDP-based browser sessions API.

For teams with existing Selenium workflows, the Steel browser provides a drop-in replacement that adds enhanced features while maintaining compatibility. You can simply use the `isSelenium` option to create a Selenium session:

```typescript
// Using the Node SDK
const session = await client.sessions.create({ isSelenium: true });
```
```python
# Using the Python SDK
session = client.sessions.create(is_selenium=True)
```

Using Curl

```bash
# Launch a Selenium session
curl -X POST http://localhost:3000/v1/sessions \
  -H "Content-Type: application/json" \
  -d '{
    "options": {
      "isSelenium": true,
      // Selenium-compatible options
    }
  }'
```

The Selenium API is fully compatible with Selenium's WebDriver protocol, so you can use any existing Selenium clients to connect to the Steel browser. **For more details on using Selenium with Steel, refer to the [Selenium Docs](https://docs.steel.dev/overview/guides/connect-with-selenium).**

### Quick Actions API
The `/scrape`, `/screenshot`, and `/pdf` endpoints let you quickly extract clean, well-formatted data from any webpage using the running Steel server. Ideal for simple, read-only, on-demand jobs:

Scrape a Web Page

Extract the HTML content of a web page.

```bash
# Example using the Actions API
curl -X POST http://0.0.0.0:3000/v1/scrape \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com",
    "waitFor": 1000
  }'
```

Take a Screenshot

Take a screenshot of a web page.
```bash
# Example using the Actions API
curl -X POST http://0.0.0.0:3000/v1/screenshot \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com",
    "fullPage": true
  }' --output screenshot.png
```

Download a PDF

Download a PDF of a web page.
```bash
# Example using the Actions API
curl -X POST http://0.0.0.0:3000/v1/pdf \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com",
    "fullPage": true
  }' --output output.pdf
```

## Get involved
Steel browser is an open-source project, and we welcome contributions!
- Questions/ideas/feedback? Come hangout on [Discord](https://discord.gg/steel-dev)
- Found a bug? Open an issue on [GitHub](https://github.com/steel-dev/steel-browser/issues)

## License
[Apache 2.0](./LICENSE)

---

Made with ❤ by the Steel team.

README.md

🔥 Open Source Browser API for AI Agents & Apps. Steel Browser is a batteries-included browser instance that lets you automate the web without worrying about infrastructure.


# Steel REPL

This package provides a simple REPL to interact with the browser instance you've created using the API.

The API exposes a WebSocket endpoint, allowing you to connect to the browser using Chrome DevTools Protocol (CDP) and use Puppeteer as usual.

## Quick Start

1. Ensure you have **Steel Browser** running, either via Docker or locally.
2. Run `npm start` to execute the script.
3. Modify `src/script.ts` as needed and rerun `npm start` to see your changes.

> Note: You might need to update the WebSocket endpoint in `src/script.ts` if your services isn't exposed on your network

For more details, refer to [Steel Browser Documentation](https://docs.steel.dev/).

repl/README.md


# React + TypeScript + Vite

This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.

Currently, two official plugins are available:

- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh
- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh

## Expanding the ESLint configuration

If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:

- Configure the top-level `parserOptions` property like this:

```js
   parserOptions: {
    ecmaVersion: 'latest',
    sourceType: 'module',
    project: ['./tsconfig.json', './tsconfig.node.json'],
    tsconfigRootDir: __dirname,
   },
```

- Replace `plugin:@typescript-eslint/recommended` to `plugin:@typescript-eslint/recommended-type-checked` or `plugin:@typescript-eslint/strict-type-checked`
- Optionally add `plugin:@typescript-eslint/stylistic-type-checked`
- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and add `plugin:react/recommended` & `plugin:react/jsx-runtime` to the `extends` list

ui/README.md


---
name: Bug report
about: Create a report to help us improve
title: "[BUG] TITLE"
labels: ''
assignees: ''

---

Issue tracker is **ONLY** used for reporting bugs. New features should be discussed in our [Discord server](https://discord.gg/steel-dev).

**Describe the bug**
A clear and concise description of what the bug is.

**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error

**Expected behavior**
A clear and concise description of what you expected to happen.

**Screenshots**
If applicable, add screenshots to help explain your problem.

**Desktop (please complete the following information):**
 - OS: [e.g. iOS]
 - Browser [e.g. chrome, safari]
 - Version [e.g. 22]

**Smartphone (please complete the following information):**
 - Device: [e.g. iPhone6]
 - OS: [e.g. iOS8.1]
 - Browser [e.g. stock browser, safari]
 - Version [e.g. 22]

**Additional context**
Add any other context about the problem here.


# Contributor Covenant Code of Conduct

## Our Pledge

In the interest of fostering an open and welcoming environment, we as
contributors and maintainers pledge to make participation in our project and
our community a harassment-free experience for everyone, regardless of age, body
size, disability, ethnicity, gender identity and expression, level of experience,
nationality, personal appearance, race, religion, or sexual identity and
orientation.

## Our Standards

Examples of behavior that contributes to creating a positive environment
include:

- Using welcoming and inclusive language
- Being respectful of differing viewpoints and experiences
- Gracefully accepting constructive criticism
- Focusing on what is best for the community
- Showing empathy towards other community members

Examples of unacceptable behavior by participants include:

- The use of sexualized language or imagery and unwelcome sexual attention or
  advances
- Trolling, insulting/derogatory comments, and personal or political attacks
- Public or private harassment
- Publishing others' private information, such as a physical or electronic
  address, without explicit permission
- Other conduct which could reasonably be considered inappropriate in a
  professional setting

## Our Responsibilities

Project maintainers are responsible for clarifying the standards of acceptable
behavior and are expected to take appropriate and fair corrective action in
response to any instances of unacceptable behavior.

Project maintainers have the right and responsibility to remove, edit, or
reject comments, commits, code, wiki edits, issues, and other contributions
that are not aligned to this Code of Conduct, or to ban temporarily or
permanently any contributor for other behaviors that they deem inappropriate,
threatening, offensive, or harmful.

## Scope

This Code of Conduct applies both within project spaces and in public spaces
when an individual is representing the project or its community. Examples of
representing a project or community includes using an official project e-mail
address, posting via an official social media account, or acting as an appointed
representative at an online or offline event. Representation of a project may be
further defined and clarified by project maintainers.

## Enforcement

Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported by contacting an individual maintainer on:

### GitHub

- @gorillamoe

> (at `GitHub username` + `@github.com`).

### Discord

- gorillamoe

All complaints will be reviewed and investigated and will result in a response that
is deemed necessary and appropriate to the circumstances. The project team is
obligated to maintain confidentiality with regard to the reporter of an incident.
Further details of specific enforcement policies may be posted separately.

Project maintainers who do not follow or enforce the Code of Conduct in good
faith may face temporary or permanent repercussions as determined by other
members of the project's leadership.

## Attribution

This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
available at [https://contributor-covenant.org/version/1/4][version]

[homepage]: https://contributor-covenant.org
[version]: https://contributor-covenant.org/version/1/4/

CODE_OF_CONDUCT.md

Bananas🍌, Cross-Platform screen 🖥 sharing 📡 made simple ⚡.


# Contributing to Bananas Screen Sharing

Thanks for checking out Bananas Screen Sharing!
We're excited to hear and learn from you.

We've put together the following guidelines to
help you figure out where you can best be helpful.

## Table of Contents

0. [Types of contributions we're looking for](#types-of-contributions-were-looking-for)
1. [Ground rules & expectations](#ground-rules--expectations)
2. [How to contribute](#how-to-contribute)
3. [Style guide](#style-guide)
4. [Documentation](#documentation)
5. [Code](#code)
6. [Setting up your environment](#setting-up-your-environment)
7. [Community](#community)

## Types of contributions we're looking for

There are many ways you can directly contribute to Bananas Screen Sharing:

- Feature requests
- Bug reports
- Code contributions
- Writing or editing documentation

## Ground rules & expectations

Before we get started,
here are a few things we expect from you (and that you should expect from others):

- Be kind and thoughtful in your conversations around this project.
  We all come from different backgrounds and projects,
  which means we likely have different perspectives on "how open source is done."
  Try to listen to others rather than convince them that your way is correct.
- Bananas is released with a [Contributor Code of Conduct](./CODE_OF_CONDUCT.md).
  By participating in this project, you agree to abide by its terms.
- Please ensure that your contribution passes all tests if you open a pull request.
  If there are test failures, you will need to address them before we can merge your contribution.
- When adding content, please consider if it is widely valuable.
  Please don't add references or links to things you or your employer have created,
  as others will do so if they appreciate it.

## How to contribute

If you'd like to contribute,
start by searching through the [pull requests](https://github.com/mistweaverco/bananas/pulls) to
see whether someone else has raised a similar idea or question.

If you don't see your idea listed, and you think it fits into the goals of this guide, open a pull request.

## Style guide

### Documentation

If you're writing documentation,
see the [style guide](.vale/styles) (which uses [vale](https://vale.sh)) to
help your prose match the rest of the documentation.

### Code

When writing code,
please follow these configurations:

- [eslint](./eslintrc.cjs)
- [EditorConfig](./.editorconfig)
- [yaml-lint](./.yamllint.yaml)

Most of them are automatically checked by the CI,
so you don't need to worry about them.

## Community

Discussions about the Bananas take place on:

- This repository's [Issues](https://github.com/mistweaverco/bananas/issues) and
  [Pull Requests](https://github.com/mistweaverco/bananas/pulls) sections
- The [Bananas Discord server](https://discord.gg/BeN43eJVWS)

Anybody is welcome to join these conversations.

Wherever possible,
do not take these conversations to private channels,
including contacting the maintainers directly.

Keeping communication public means everybody can benefit and learn from the conversation.

CONTRIBUTING.md


# Privacy Policy

Effective Date: 2024-12-03

Your privacy is important to us.
This Privacy Policy outlines how we handle and protect your information when you use
Bananas Screen Sharing (the "App").

By using the App, you agree to the terms of this Privacy Policy.

### 1. Data Collection

We do not collect, store, or process any personal or usage data from users of the App.
The App functions solely to establish a peer-to-peer connection between users
No personal information, identifiers, or activity data are transmitted to us or any third-party;
excluding stun and turn servers for negotiation of connection details like IP addresses and ports.

### 2. Data Usage

The App interacts with stun and turn servers to establish a peer-to-peer connection between users.

### 3. Third-Party Services

The App uses the official stun server provided by Google
if not provided by the user.

This is required for the negotiation of connection details like IP addresses and ports,
to establish a peer-to-peer connection between users.

### 4. Security

Although we do not collect any data,
we prioritize security in the development and maintenance of the App to
ensure that your use of it remains safe.

The App only communicates with the stun or turn servers
that you can configure yourself,
for the purpose of establishing a peer-to-peer connection and
does not expose your data to any other services or entities.

### 5. User Consent

By using the App,
you consent to the interaction between the configured stun or turn servers and the App,
as described in this policy.

You understand that the App does not collect or store any personal data.

### 6. Changes to the Privacy Policy

We reserve the right to modify this Privacy Policy at any time.
Any changes will be posted on this page with an updated "Effective Date."

Your continued use of the App after changes to this Privacy Policy indicates
your acceptance of the revised terms.

### 7. Contact Us

If you have any questions or concerns about this Privacy Policy or the App,
please contact us via filing an issue on the
[GitHub repository](https://github.com/mistweaverco/bananas/issues/new).

PRIVACY.md


![Bananas Screen Sharing Logo](logo.svg)

# Bananas Screen Sharing

[![Downloads](https://img.shields.io/github/downloads/mistweaverco/bananas/total.svg?style=for-the-badge)](https://getbananas.net/)
[![GitHub release (latest by date)](https://img.shields.io/github/v/release/mistweaverco/bananas?style=for-the-badge)](https://github.com/mistweaverco/bananas/releases/latest)

[Install](#install) • [Website](https://getbananas.net/) • [Tutorial](https://getbananas.net/tutorial) • [Privacy Policy](./PRIVACY.md) • [Terms of Service](./TOS.md) • [Code of Conduct](./CODE_OF_CONDUCT.md)

Bananas Screen Sharing is a simple and
easy-to-use screen sharing tool for Mac, Windows, and Linux.

It utilizes a peer-to-peer connection to share your screen with others,
without the need for an account or any server infrastructure
(except for the stun, turn and signaling servers that are needed for exchanging the initial connection information)

## Install

Grab the latest release from the
[GitHub releases page](https://github.com/mistweaverco/bananas/releases/latest).

Or if you are on Mac you can install it via homebrew with

```shell
brew install --cask bananas
```

README.md


# Security Policy

## Supported Versions

Versions currently being supported with security updates.

| Version | Supported          |
| ------- | ------------------ |
| 0.0.x   | :white_check_mark: |

## Reporting a Vulnerability

Security vulnerabilites ahould be communicated with
the maintainers in private.

### GitHub

- @gorillamoe

> (at `GitHub username` + `@github.com`).

### Discord

- gorillamoe

SECURITY.md


# Terms of Service

Terms of Service for Bananas Screen Sharing
Effective Date: 2024-12-03

These Terms of Service ("Terms") govern your use of the Bananas Screen Sharing (the "App").

By using the App, you agree to these Terms.
If you do not agree to these Terms, you may not use the App.

### 1. Acceptance of Terms

By installing, accessing, or using the App, you agree to comply with these Terms.
If you do not agree to these Terms,
you must not use the App.

We reserve the right to modify these Terms at any time,
and your continued use of the App after any such modifications indicates your acceptance of the new terms.

### 2. License

See [LICENSE](LICENSE) for the license under which the App is provided.

### 4. User Conduct

When using the App, you agree to:

Use the App solely for its intended purpose.
Not attempt to interfere with the App's functionality or access any other users' information.

### 5. Disclaimer of Warranties

The App is provided on an "as-is" and "as-available" basis,
without any warranties of any kind. We do not guarantee that the App will be error-free,
secure, or uninterrupted. You use the App at your own risk.

### 6. Limitation of Liability

To the maximum extent permitted by law,
we shall not be liable for any damages arising from the use or inability to use the App,
including but not limited to direct, indirect, incidental, or consequential damages.
This includes, without limitation, any loss of data,
interruption of service, or
issues resulting from third-party interactions (e.g., stun or turn servers).

### 7. Termination

We reserve the right to terminate your access to the App at any time for any reason,
including but not limited to your violation of these Terms.
Upon termination, the rights and licenses granted to you under these Terms will immediately cease.

### 8. Third-Party Services

The App may use third-party services, such as stun or turn servers,
to facilitate its functionality.

### 9. Governing Law

These Terms shall be governed and construed in accordance with the laws of Germany.

Any legal actions or disputes arising in connection with these Terms
will be resolved in the courts of Germany.

### 10. Changes to These Terms

We reserve the right to modify these Terms at any time.
Any changes will be posted on this page with an updated "Effective Date."
Your continued use of the App after changes to
the Terms indicates your acceptance of the modified terms.

### 11. Contact Us

If you have any questions or concerns about these Terms,
please contact us via filing an issue on the
[GitHub repository](https://github.com/mistweaverco/bananas/issues/new).

TOS.md


---
name: Bug report
about: Create a report to help us improve
title: ''
labels: bug
assignees: ''
---

**Describe the bug**
A clear and concise description of what the bug is.

**To Reproduce**
Steps to reproduce the behavior:

1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error

**Expected behavior**
A clear and concise description of what you expected to happen.

**Screenshots**
If applicable, add screenshots to help explain your problem.

**Desktop (please complete the following information):**

- OS: [e.g. iOS]
- Version [e.g. 22]

**Additional context**
Add any other context about the problem here.


---
name: Feature request
about: Suggest an idea for this project
title: ''
labels: enhancement
assignees: ''
---

**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

**Describe the solution you'd like**
A clear and concise description of what you want to happen.

**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.

**Additional context**
Add any other context or screenshots about the feature request here.


# Contributing to Awesome MCP Servers

Contributions are welcome and encouraged!  Whether you're fixing a typo, adding a new server, or suggesting improvements, your help is appreciated.

## How to Contribute

1. **Fork the repository:** Click the "Fork" button in the top right corner of the GitHub page.

2. **Create a new branch:**  Create a new branch for your changes.  This keeps your changes separate from the main project until they're ready to be merged.  A good branch name describes the changes you're making, e.g., `add-new-server` or `fix-typo`.

   ```bash
   git checkout -b add-new-server
   ```

3. **Make your changes:** Edit the `README.md` file with your additions or corrections.  Please follow the existing format and style.  When adding a new server, make sure to include:

    * The server name, linked to its repository.
    * A brief description of the server's functionality.
    * Categorize the server appropriately under the relevant section.  If a new category is needed, please create one and maintain alphabetical order.

4. **Commit your changes:** Commit your changes with a clear and concise message explaining what you've done.

   ```bash
   git commit -m "Add new XYZ server"
   ```

5. **Push your branch:** Push your branch to your forked repository.

   ```bash
   git push origin add-new-server
   ```

6. **Create a pull request:** Go to the original repository and click the "New pull request" button.  Select your forked repository and branch.  Provide a clear title and description of your changes in the pull request.

7. **Review and merge:** Your pull request will be reviewed by the maintainers.  They may suggest changes or ask for clarification.  Once the review is complete, your changes will be merged into the main project.

## Guidelines

* **Keep it consistent:** Follow the existing format and style of the `README.md` file.  This includes formatting, capitalization, and punctuation.
* **Alphabetical order:**  Maintain alphabetical order within each category of servers.  This makes it easier to find specific servers.
* **Accurate information:** Ensure that all information is accurate and up-to-date.  Double-check links and descriptions before submitting your changes.
* **One server per line:** List each server on a separate line for better readability.
* **Clear descriptions:** Write concise and informative descriptions for each server.  Explain what the server does and what its key features are.

Thank you for contributing!

CONTRIBUTING.md

A collection of MCP servers.


# 素晴らしいMCPサーバー [![Awesome](https://awesome.re/badge.svg)](https://awesome.re)

[![English](https://img.shields.io/badge/English-Click-yellow)](README.md)
[![中文文档](https://img.shields.io/badge/中文文档-点击查看-orange)](README-zh.md)
[![日本語](https://img.shields.io/badge/日本語-クリック-青)](README-ja.md)
[![Discord](https://img.shields.io/discord/1312302100125843476?logo=discord&label=discord)](https://glama.ai/mcp/discord)
[![Subreddit subscribers](https://img.shields.io/reddit/subreddit-subscribers/mcp?style=flat&logo=reddit&label=subreddit)](https://www.reddit.com/r/mcp/)

素晴らしいモデルコンテキストプロトコル（MCP）サーバーの厳選リスト。

* [MCPとは何ですか？](#what-is-mcp)
* [チュートリアル](#tutorials)
* [サーバー実装](#server-implementations)
* [フレームワーク](#frameworks)
* [ヒントとコツ](#tips-and-tricks)

## MCPとは何ですか？

[MCP](https://modelcontextprotocol.io/) は、標準化されたサーバー実装を通じて、AIモデルがローカルおよびリモートリソースと安全に対話できるようにするオープンプロトコルです。このリストは、ファイルアクセス、データベース接続、API統合、その他のコンテキストサービスを通じてAIの機能を拡張する、実運用および実験的なMCPサーバーに焦点を当てています。

## チュートリアル

* [モデルコンテキストプロトコル (MCP) クイックスタート](https://glama.ai/blog/2024-11-25-model-context-protocol-quickstart)
* [SQLiteデータベースを使用するためのClaudeデスクトップアプリのセットアップ](https://youtu.be/wxCCzo9dGj0)

## コミュニティ

* [r/mcp Reddit](https://www.reddit.com/r/mcp)
* [Discordサーバー](https://glama.ai/mcp/discord)

## 凡例

* 🎖 – 公式実装
* 🐍 – Pythonコードベース
* 📇 – TypeScriptコードベース
* 🏎 – Goコードベース
* #⃣ – C#コードベース
* ☁ - クラウドサービス
* 🏠 - ローカルサービス

## サーバー実装

* 📂 - [ブラウザ自動化](#browser-automation)
* ☁ - [クラウドプラットフォーム](#cloud-platforms)
* 💬 - [コミュニケーション](#communication)
* 👤 - [顧客データプラットフォーム](#customer-data-platforms)
* 🗄 - [データベース](#databases)
* 🛠 - [開発者ツール](#developer-tools)
* 📂 - [ファイルシステム](#file-systems)
* 🧠 - [知識と記憶](#knowledge--memory)
* 🗺 - [位置情報サービス](#location-services)
* 📊 - [監視](#monitoring)
* 🔎 - [検索](#search)
* 🔄 - [旅行と交通](#travel-and-transportation)
* 🔄 - [バージョン管理](#version-control)
* 🛠 - [その他のツールと統合](#other-tools-and-integrations)

### 📂 ブラウザ自動化

Webコンテンツのアクセスと自動化機能。AIに優しい形式でWebコンテンツを検索、スクレイピング、処理することができます。

- [@executeautomation/playwright-mcp-server](https://github.com/executeautomation/mcp-playwright) 🌐⚡ - Playwrightを使用したブラウザ自動化とWebスクレイピングのためのMCPサーバー
- [@automatalabs/mcp-server-playwright](https://github.com/Automata-Labs-team/MCP-Server-Playwright) 🌐🖱 - Playwrightを使用したブラウザ自動化のためのMCPサーバー
- [@modelcontextprotocol/server-puppeteer](https://github.com/modelcontextprotocol/servers/tree/main/src/puppeteer) 📇 🏠 - Webスクレイピングとインタラクションのためのブラウザ自動化
- [@kimtaeyoon83/mcp-server-youtube-transcript](https://github.com/kimtaeyoon83/mcp-server-youtube-transcript) 📇 ☁ - AI分析のためのYouTube字幕とトランスクリプトの取得
- [@kimtth/mcp-aoai-web-browsing](https://github.com/kimtth/mcp-aoai-web-browsing) 🐍 🏠 - Azure OpenAIとPlaywrightを使用した「最小限の」サーバー/クライアントMCP実装。

### ☁ クラウドプラットフォーム

クラウドプラットフォームサービスの統合。クラウドインフラストラクチャとサービスの管理と対話を可能にします。

- [Cloudflare MCP Server](https://github.com/cloudflare/mcp-server-cloudflare) 🎖 📇 ☁ - Workers、KV、R2、D1を含むCloudflareサービスとの統合
- [Kubernetes MCP Server](https://github.com/strowk/mcp-k8s-go) - 🏎 ☁ MCPを通じたKubernetesクラスター操作

### 💬 コミュニケーション

メッセージ管理とチャネル操作のためのコミュニケーションプラットフォームとの統合。AIモデルがチームコミュニケーションツールと対話できるようにします。

- [@modelcontextprotocol/server-slack](https://github.com/modelcontextprotocol/servers/tree/main/src/slack) 📇 ☁ - チャネル管理とメッセージングのためのSlackワークスペース統合
- [@modelcontextprotocol/server-bluesky](https://github.com/keturiosakys/bluesky-context-server) 📇 ☁ - クエリとインタラクションのためのBlueskyインスタンス統合
- [MarkusPfundstein/mcp-gsuite](https://github.com/MarkusPfundstein/mcp-gsuite) - 🐍 ☁ - GmailとGoogleカレンダーとの統合。
- [gotoolkits/wecombot](https://github.com/gotoolkits/mcp-wecombot-server.git) - 🚀 ☁  - MCPサーバーアプリケーションは、WeComグループロボットにさまざまなタイプのメッセージを送信します。

### 👤 顧客データプラットフォーム

顧客データプラットフォーム内の顧客プロファイルへのアクセスを提供します。

- [sergehuber/inoyu-mcp-unomi-server](https://github.com/sergehuber/inoyu-mcp-unomi-server) 📇 ☁ - Apache Unomi CDPサーバー上のプロファイルにアクセスし、更新するためのMCPサーバー。

### 🗄 データベース

スキーマ検査機能を備えた安全なデータベースアクセス。読み取り専用アクセスを含む構成可能なセキュリティ制御を使用してデータをクエリおよび分析することができます。

- [cr7258/elasticsearch-mcp-server](https://github.com/cr7258/elasticsearch-mcp-server) 🐍 🏠 - MCPサーバーの実装で、Elasticsearchとのインタラクションを提供します
- [domdomegg/airtable-mcp-server](https://github.com/domdomegg/airtable-mcp-server) 📇 🏠 - スキーマ検査、読み取り/書き込み機能を備えた Airtable データベース統合
- [LucasHild/mcp-server-bigquery](https://github.com/LucasHild/mcp-server-bigquery) 🐍 ☁ - スキーマ検査とクエリ機能を備えたBigQueryデータベース統合
- [ergut/mcp-bigquery-server](https://github.com/ergut/mcp-bigquery-server) 📇 ☁ - Google BigQuery統合のためのサーバー実装で、直接的なBigQueryデータベースアクセスとクエリ機能を提供
- [designcomputer/mysql_mcp_server](https://github.com/designcomputer/mysql_mcp_server) 🐍 🏠 - 構成可能なアクセス制御、スキーマ検査、包括的なセキュリティガイドラインを備えたMySQLデータベース統合
- [@modelcontextprotocol/server-postgres](https://github.com/modelcontextprotocol/servers/tree/main/src/postgres) 📇 🏠 - スキーマ検査とクエリ機能を備えたPostgreSQLデータベース統合
- [@modelcontextprotocol/server-sqlite](https://github.com/modelcontextprotocol/servers/tree/main/src/sqlite) 🐍 🏠 - 組み込みの分析機能を備えたSQLiteデータベース操作
- [@joshuarileydev/supabase-mcp-server](https://github.com/joshuarileydev/supabase) - Supabaseでプロジェクトと組織を管理および作成するためのSupabase MCPサーバー
- [ktanaka101/mcp-server-duckdb](https://github.com/ktanaka101/mcp-server-duckdb) 🐍 🏠 - スキーマ検査とクエリ機能を備えたDuckDBデータベース統合
- [QuantGeekDev/mongo-mcp](https://github.com/QuantGeekDev/mongo-mcp) 📇 🏠 - LLMがデータベースと直接対話できるようにするMongoDB統合。
- [tinybirdco/mcp-tinybird](https://github.com/tinybirdco/mcp-tinybird) 🐍 ☁ - クエリとAPI機能を備えたTinybird統合
- [kiliczsh/mcp-mongo-server](https://github.com/kiliczsh/mcp-mongo-server) 📇 🏠 - MongoDBのためのモデルコンテキストプロトコルサーバー
- [KashiwaByte/vikingdb-mcp-server](https://github.com/KashiwaByte/vikingdb-mcp-server) 🐍 ☁ - コレクションとインデックスの紹介、ベクトルストアと検索機能を備えたVikingDB統合。
- [runekaagaard/mcp-alchemy](https://github.com/runekaagaard/mcp-alchemy) 🐍 🏠 - PostgreSQL、MySQL、MariaDB、SQLite、Oracle、MS SQL Serverなど多数のデータベースをサポートするSQLAlchemyベースの汎用データベース統合。スキーマと関係の検査、大規模データセット分析機能を備えています。

### 💻 開発者ツール

開発ワークフローと環境管理を強化するツールと統合。

- [QuantGeekDev/docker-mcp](https://github.com/QuantGeekDev/docker-mcp) 🏎 🏠 - MCPを通じたDockerコンテナの管理と操作
- [zcaceres/fetch-mcp](https://github.com/zcaceres/fetch-mcp) 📇 🏠 - JSON、テキスト、HTMLデータを柔軟に取得するためのMCPサーバー
- [zcaceres/gtasks-mcp](https://github.com/zcaceres/gtasks-mcp) - 📇 ☁ - Google タスクを管理するための MCP サーバー
- [snaggle-ai/openapi-mcp-server](https://github.com/snaggle-ai/openapi-mcp-server) 🏎 🏠 - Open API spec (v3) を使用して任意のHTTP/REST APIサーバーに接続
- [@joshuarileydev/terminal-mcp-server](https://www.npmjs.com/package/@joshuarileydev/terminal-mcp-server) 📇 🏠 - 任意のシェルターミナルコマンドを実行するためのMCPサーバー
- [tumf/mcp-text-editor](https://github.com/tumf/mcp-text-editor) - ラインエディタ 行単位の取得と編集ができるので、特に大きなファイルの一部書き換えを効率的に行う
- [ferrislucas/iterm-mcp](https://github.com/ferrislucas/iterm-mcp) 🖥 🛠 💬 - iTermへのアクセスを提供するモデルコンテキストプロトコルサーバー。コマンドを実行し、iTermターミナルで見た内容について質問することができます。

### 📂 ファイルシステム

構成可能な権限を備えたローカルファイルシステムへの直接アクセスを提供します。指定されたディレクトリ内のファイルを読み取り、書き込み、管理することができます。

- [@modelcontextprotocol/server-filesystem](https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem) 📇 🏠 - ローカルファイルシステムへの直接アクセス。
- [@modelcontextprotocol/server-google-drive](https://github.com/modelcontextprotocol/servers/tree/main/src/gdrive) 📇 ☁ - ファイルのリスト、読み取り、検索のためのGoogle Drive統合
- [mark3labs/mcp-filesystem-server](https://github.com/mark3labs/mcp-filesystem-server) 🏎 🏠 - ローカルファイルシステムアクセスのためのGolang実装。

### 🧠 知識と記憶

知識グラフ構造を使用した永続的なメモリストレージ。セッション間で構造化情報を維持およびクエリすることができます。

- [@modelcontextprotocol/server-memory](https://github.com/modelcontextprotocol/servers/tree/main/src/memory) 📇 🏠 - コンテキストを維持するための知識グラフベースの長期記憶システム
- [/CheMiguel23/MemoryMesh](https://github.com/CheMiguel23/MemoryMesh) 📇 🏠 - AIロールプレイとストーリー生成に焦点を当てた強化されたグラフベースのメモリ

### 🗺 位置情報サービス

地理および位置ベースのサービス統合。地図データ、方向、および場所情報へのアクセスを提供します。

- [@modelcontextprotocol/server-google-maps](https://github.com/modelcontextprotocol/servers/tree/main/src/google-maps) 📇 ☁ - 位置情報サービス、ルート計画、および場所の詳細のためのGoogle Maps統合

### 📊 監視

アプリケーション監視データへのアクセスと分析。エラーレポートとパフォーマンスメトリクスをレビューすることができます。

- [@modelcontextprotocol/server-sentry](https://github.com/modelcontextprotocol/servers/tree/main/src/sentry) 🐍 ☁ - エラートラッキングとパフォーマンス監視のためのSentry.io統合
- [@modelcontextprotocol/server-raygun](https://github.com/MindscapeHQ/mcp-server-raygun) 📇 ☁ - クラッシュレポートとリアルユーザーモニタリングのためのRaygun API V3統合

### 🔎 検索

- [@modelcontextprotocol/server-brave-search](https://github.com/modelcontextprotocol/servers/tree/main/src/brave-search) 📇 ☁ - Braveの検索APIを使用したWeb検索機能
- [@angheljf/nyt](https://github.com/angheljf/nyt) 📇 ☁ - NYTimes APIを使用して記事を検索
- [@modelcontextprotocol/server-fetch](https://github.com/modelcontextprotocol/servers/tree/main/src/fetch) 🐍 🏠 ☁ - AI消費のための効率的なWebコンテンツの取得と処理
- [ac3xx/mcp-servers-kagi](https://github.com/ac3xx/mcp-servers-kagi) 📇 ☁ - Kagi検索API統合
- [theishangoswami/exa-mcp-server](https://github.com/theishangoswami/exa-mcp-server) 📇 ☁ - Exa AI検索API
- [exa-labs/exa-mcp-server](https://github.com/exa-labs/exa-mcp-server) 🎖 📇 ☁ – モデルコンテキストプロトコル（MCP）サーバーは、ClaudeなどのAIアシスタントがExa AI検索APIを使用してWeb検索を行うことを可能にします。この設定により、AIモデルは安全かつ制御された方法でリアルタイムのWeb情報を取得できます。
- [fatwang2/search1api-mcp](https://github.com/fatwang2/search1api-mcp) 📇 ☁ - search1apiを介した検索（有料APIキーが必要）
- [Tomatio13/mcp-server-tavily](https://github.com/Tomatio13/mcp-server-tavily) ☁ 🐍 – Tavily AI検索API
- [blazickjp/arxiv-mcp-server](https://github.com/blazickjp/arxiv-mcp-server) ☁ 🐍 - ArXiv研究論文を検索
- [mzxrai/mcp-webresearch](https://github.com/mzxrai/mcp-webresearch) 🔍📚 - Googleを検索し、任意のトピックに関する深いWebリサーチを行う
- [andybrandt/mcp-simple-arxiv](https://github.com/andybrandt/mcp-simple-arxiv) - 🐍 ☁  MCPを使用してLLMがArXivの論文を検索および読む
- [apify/mcp-server-rag-web-browser](https://github.com/apify/mcp-server-rag-web-browser) 📇 ☁ - Apify の RAG Web Browser Actor 用の MCP サーバーで、ウェブ検索を実行し、URL をスクレイピングし、Markdown 形式でコンテンツを返します。
- [Ihor-Sokoliuk/MCP-SearXNG](https://github.com/ihor-sokoliuk/mcp-searxng) 📇 🏠/☁ - [SearXNG](https://docs.searxng.org)のモデルコンテキストプロトコルサーバー
- [erithwik/mcp-hn](https://github.com/erithwik/mcp-hn) 🐍 ☁ - Hacker Newsの検索、トップストーリーの取得などを行うMCPサーバー。
- [chanmeng/google-news-mcp-server](https://github.com/ChanMeng666/server-google-news) 📇 ☁ - 自動トピック分類、多言語サポート、[SerpAPI](https://serpapi.com/)を通じたヘッドライン、ストーリー、関連トピックの包括的な検索機能を備えたGoogle News統合。

### 🔒 セキュリティ

- [Security Audit MCP Server](https://github.com/qianniuspace/mcp-security-audit) 📇🛡☁ 強力なモデルコンテキストプロトコル（MCP）サーバーで、npmパッケージ依存関係のセキュリティ脆弱性を監査します。リモートnpmレジストリ統合を備えたリアルタイムセキュリティチェックを使用して構築されています。

### 🚆 旅行と交通

旅行および交通情報へのアクセス。スケジュール、ルート、およびリアルタイムの旅行データをクエリすることができます。

- [NS Travel Information MCP Server](https://github.com/r-huijts/ns-mcp-server) 📇 ☁ - オランダ鉄道（NS）の旅行情報、スケジュール、およびリアルタイムの更新にアクセス

### 🔄 バージョン管理

Gitリポジトリおよびバージョン管理プラットフォームとの対話。標準化されたAPIを通じて、リポジトリ管理、コード分析、プルリクエスト処理、問題追跡、およびその他のバージョン管理操作を実行できます。

- [@modelcontextprotocol/server-github](https://github.com/modelcontextprotocol/servers/tree/main/src/github) 📇 ☁ - リポジトリ管理、PR、問題などのためのGitHub API統合
- [@modelcontextprotocol/server-gitlab](https://github.com/modelcontextprotocol/servers/tree/main/src/gitlab) 📇 ☁ 🏠 - プロジェクト管理およびCI/CD操作のためのGitLabプラットフォーム統合
- [@modelcontextprotocol/server-git](https://github.com/modelcontextprotocol/servers/tree/main/src/git) 🐍 🏠 - ローカルリポジトリの読み取り、検索、および分析を含む直接的なGitリポジトリ操作

### 🛠 その他のツールと統合

- [apify/actors-mcp-server](https://github.com/apify/actors-mcp-server) 📇 ☁ - 3,000以上の事前構築されたクラウドツール（Actors として知られる）を使用して、ウェブサイト、eコマース、ソーシャルメディア、検索エンジン、地図などからデータを抽出できます。
- [zcaceres/markdownify-mcp](https://github.com/zcaceres/markdownify-mcp) 📇 🏠 - ほぼすべてのファイルやウェブコンテンツをMarkdownに変換するMCPサーバー
- [mzxrai/mcp-openai](https://github.com/mzxrai/mcp-openai) 📇 ☁ - OpenAIの最も賢いモデルとチャット
- [mrjoshuak/godoc-mcp](https://github.com/mrjoshuak/godoc-mcp) 🏎 🏠 - Goドキュメントサーバーで、AIアシスタントがパッケージドキュメントとタイプにスマートにアクセスできるようにします。
- [pierrebrunelle/mcp-server-openai](https://github.com/pierrebrunelle/mcp-server-openai) 🐍 ☁ - MCPプロトコルを使用してClaudeから直接OpenAIモデルにクエリを送信
- [@modelcontextprotocol/server-everything](https://github.com/modelcontextprotocol/servers/tree/main/src/everything) 📇 🏠 - MCPプロトコルのすべての機能を実行するMCPサーバー
- [baba786/phabricator-mcp-server](https://github.com/baba786/phabricator-mcp-server) 🐍 ☁ - Phabricator APIとの対話
- [MarkusPfundstein/mcp-obsidian](https://github.com/MarkusPfundstein/mcp-obsidian) 🐍 ☁ 🏠 - REST APIを介してObsidianと対話
- [calclavia/mcp-obsidian](https://github.com/calclavia/mcp-obsidian) 📇 🏠 - これは、Claude Desktop（または任意のMCPクライアント）がMarkdownノートを含むディレクトリ（Obsidianボールトなど）を読み取り、検索できるようにするコネクタです。
- [anaisbetts/mcp-youtube](https://github.com/anaisbetts/mcp-youtube) 📇 ☁ - YouTube字幕の取得
- [danhilse/notion_mcp](https://github.com/danhilse/notion_mcp) 🐍 ☁ - NotionのAPIと統合して個人のToDoリストを管理
- [rusiaaman/wcgw](https://github.com/rusiaaman/wcgw/blob/main/src/wcgw/client/mcp_server/Readme.md) 🐍 🏠 - 自律的なシェル実行、コンピュータ制御、およびコーディングエージェント。（Mac）
- [reeeeemo/ancestry-mcp](https://github.com/reeeeemo/ancestry-mcp) 🐍 🏠 - AIが.gedファイルと遺伝データを読み取ることができるようにします。
- [sirmews/apple-notes-mcp](https://github.com/sirmews/apple-notes-mcp) 🐍 🏠 - AIがローカルのApple Notesデータベースから読み取ることができるようにします（macOSのみ）
- [anjor/coinmarket-mcp-server](https://github.com/anjor/coinmarket-mcp-server) 🐍 🏠 - 暗号通貨のリストと見積もりを取得するためのCoinmarket API統合
- [suekou/mcp-notion-server](https://github.com/suekou/mcp-notion-server) 📇 🏠 - Notion APIとの対話
- [amidabuddha/unichat-mcp-server](https://github.com/amidabuddha/unichat-mcp-server) 🐍/📇 ☁ - MCPプロトコルを使用してOpenAI、MistralAI、Anthropic、xAI、またはGoogle AIにリクエストを送信するためのツールまたは事前定義されたプロンプト。ベンダーAPIキーが必要
- [g0t4/mcp-server-commands](https://github.com/g0t4/mcp-server-commands) 📇 🏠 - コマンドを実行し、その出力を含める。ツールとプロンプト。
- [evalstate/mcp-miro](https://github.com/evalstate/mcp-miro) 📇 ☁ - MIROホワイトボードにアクセスし、アイテムを一括作成および読み取り。REST APIのOAUTHキーが必要。
- [sooperset/mcp-atlassian](https://github.com/sooperset/mcp-atlassian) 🐍 ☁ - Confluenceワークスペースの自然言語検索とコンテンツアクセス
- [pyroprompts/any-chat-completions-mcp](https://github.com/pyroprompts/any-chat-completions-mcp) - Perplexity、Groq、xAIなどの他のOpenAI SDK互換のチャット完了APIとチャット
- [anaisbetts/mcp-installer](https://github.com/anaisbetts/mcp-installer) 🐍 🏠 - 他のMCPサーバーをインストールするMCPサーバー。
- [tanigami/mcp-server-perplexity](https://github.com/tanigami/mcp-server-perplexity) 🐍 ☁ - Perplexity APIとの対話。
- [future-audiences/wikimedia-enterprise-model-context-protocol](https://gitlab.wikimedia.org/repos/future-audiences/wikimedia-enterprise-model-context-protocol) 🐍 ☁  - Wikipedia記事検索API
- [andybrandt/mcp-simple-timeserver](https://github.com/andybrandt/mcp-simple-timeserver) 🐍 🏠☁ - クライアントマシンのローカル時間またはNTPサーバーからの現在のUTC時間を確認するためのMCPサーバー
- [andybrandt/mcp-simple-openai-assistant](https://github.com/andybrandt/mcp-simple-openai-assistant) - 🐍 ☁  MCPを使用してOpenAIアシスタントと対話（Claudeは任意のGPTモデルをアシスタントとして使用できます）
- [@joshuarileydev/simulator-mcp-server](https://www.npmjs.com/package/@joshuarileydev/simulator-mcp-server) - 📇 🏠 iOSシミュレータを制御し、シミュレータを起動し、アプリをインストール/起動するためのMCPサーバー。
- [tumf/mcp-shell-server](https://github.com/tumf/mcp-shell-server) シェルからホワイトリストにあるコマンドを実行して結果を返すMCPサーバ
- [apinetwork/piapi-mcp-server](https://github.com/apinetwork/piapi-mcp-server) 📇 ☁ PiAPI MCPサーバーは、ユーザーがClaudeや他のMCP互換アプリから直接Midjourney/Flux/Kling/Hunyuan/Udio/Trellisでメディアコンテンツを生成することを可能にします。
- [gotoolkits/DifyWorkflow](https://github.com/gotoolkits/mcp-difyworkflow-server) - 🚀 ☁ MCP サーバーの Tools を使用して、Dify AI プラットフォーム上でカスタムされたワークフローを検索および実行する
- [boilingdata/mcp-server-and-gw](https://github.com/boilingdata/mcp-server-and-gw) サンプルサーバーとMCPクライアントを備えたMCP stdioからHTTP SSEへのトランスポートゲートウェイ。
- [lightconetech/mcp-gateway](https://github.com/lightconetech/mcp-gateway) MCP SSEサーバーのゲートウェイデモ。
- [sparfenyuk/mcp-proxy](https://github.com/sparfenyuk/mcp-proxy) 🐍 MCP stdioからSSEへのトランスポートゲートウェイ。

## フレームワーク

- [Genkit MCP](https://github.com/firebase/genkit/tree/main/js/plugins/mcp) 📇 – [Genkit](https://github.com/firebase/genkit/tree/main) とモデルコンテキストプロトコル（MCP）との統合を提供します。
- [@modelcontextprotocol/server-langchain](https://github.com/rectalogic/langchain-mcp) 🐍 - LangChainでのMCPツール呼び出しサポートを提供し、LangChainワークフローにMCPツールを統合できるようにします。
- [mark3labs/mcp-go](https://github.com/mark3labs/mcp-go) 🏎 - MCPサーバーとクライアントを構築するためのGolang SDK。
- [FastMCP](https://github.com/jlowin/fastmcp) 🐍 - PythonでMCPサーバーを構築するための高レベルフレームワーク
- [mcp-rs-template](https://github.com/linux-china/mcp-rs-template) 🦀 - RustのためのMCP CLIサーバーテンプレート
- [Foxy Contexts](https://github.com/strowk/foxy-contexts) 🏎 - 機能テストを含む宣言的にMCPサーバーを記述するためのGolangライブラリ
- [salty-flower/ModelContextProtocol.NET](https://github.com/salty-flower/ModelContextProtocol.NET) #⃣🏠 - .NET 9上でNativeAOT対応のMCPサーバーを構築するためのC# SDK ⚡ 🔌
- [@marimo-team/codemirror-mcp](https://github.com/marimo-team/codemirror-mcp) - リソースメンションとプロンプトコマンドのためのModel Context Protocol (MCP)を実装するCodeMirror拡張

## クライアント

- [SecretiveShell/MCP-Bridge](https://github.com/SecretiveShell/MCP-Bridge) 🐍 既存のOpenAI互換クライアントでMCPを使用するためのOpenAIミドルウェアプロキシ
- [3choff/MCP-Chatbot](https://github.com/3choff/mcp-chatbot) シンプルでありながら強力な⭐CLIチャットボットで、ツールサーバーを任意のOpenAI互換のLLM APIと統合します。
- [zed-industries/zed](https://github.com/zed-industries/zed) Atomの作成者によるマルチプレイヤーコードエディタ
- [firebase/genkit](https://github.com/firebase/genkit) エージェントおよびデータ変換フレームワーク
- [continuedev/continue](https://github.com/continuedev/continue) VSCodeの自動補完およびチャットツール（フル機能サポート）
- [MCP-Connect](https://github.com/EvalsOne/MCP-Connect) クラウドベースのAIサービスがローカルのStdioベースのMCPサーバーにHTTP/HTTPSリクエストでアクセスできるようにするツール

## ヒントとコツ

### LLMがMCPを使用する方法を通知するための公式プロンプト

モデルコンテキストプロトコルについてClaudeに質問したいですか？

プロジェクトを作成し、このファイルを追加します：

https://modelcontextprotocol.io/llms-full.txt

これで、ClaudeはMCPサーバーの作成方法やその動作について質問に答えることができます。

- https://www.reddit.com/r/ClaudeAI/comments/1h3g01r/want_to_ask_claude_about_model_context_protocol/

## スター履歴

 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=punkpeye/awesome-mcp-servers&type=Date&theme=dark" />
   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=punkpeye/awesome-mcp-servers&type=Date" />

 </picture>

README-ja.md

A collection of MCP servers.