mcp-xray-pilot 0.10.0

package/data/docs/transports__transports_grpc.md

@@ -0,0 +1,137 @@
+---
+url: https://xtls.github.io/en/config/transports/grpc.html
+source_url: https://raw.githubusercontent.com/XTLS/Xray-docs-next/main/docs/en/config/transports/grpc.md
+title: gRPC
+category: transports
+slug: transports/grpc
+fetched_at: 2026-05-04T18:43:03.782Z
+---
+# gRPC
+
+A transport protocol based on gRPC.
+
+It is based on the HTTP/2 protocol and, theoretically, can be relayed through other servers that support HTTP/2 (such as Nginx).
+gRPC (HTTP/2) has built-in multiplexing. It is not recommended to enable mux.cool when using gRPC and HTTP/2.
+
+::: danger
+**It is recommended to switch to [XHTTP](https://github.com/XTLS/Xray-core/discussions/4113). Its advantages over gRPC are noted in the STREAM-UP/ONE section.**
+:::
+
+::: warning ⚠⚠⚠
+
+- gRPC does not support specifying Host. Please fill in the **correct domain name** in the outbound proxy address, or fill in `ServerName` in `(x)tlsSettings`, otherwise the connection will fail.
+- gRPC does not support falling back to other services.
+- gRPC services are at risk of active probing. It is recommended to use reverse proxy tools such as Caddy or Nginx to split traffic via Path prefix.
+  :::
+
+::: tip
+If you use reverse proxies like Caddy or Nginx, please note the following:
+
+- Ensure the reverse proxy server has enabled HTTP/2.
+- Use HTTP/2 or h2c (Caddy), grpc_pass (Nginx) to connect to Xray.
+- The Path for normal mode is `/${serviceName}/Tun`, and for Multi mode is `/${serviceName}/TunMulti`.
+- If you need to receive the client IP, you can pass the client IP by having Caddy / Nginx send the `X-Real-IP` header.
+  :::
+
+::: tip
+If you are using fallback, please note the following:
+
+- Falling back to gRPC is not recommended due to the risk of active probing.
+- Please ensure `h2` is in the first position in (x)tlsSettings.alpn, otherwise gRPC (HTTP/2) may fail to complete the TLS handshake.
+- gRPC cannot be split by Path.
+  :::
+
+## GRPCObject
+
+`GRPCObject` corresponds to the `grpcSettings` item in the transport configuration.
+
+```json
+{
+  "authority": "grpc.example.com",
+  "serviceName": "name",
+  "multiMode": false,
+  "user_agent": "custom user agent",
+  "idle_timeout": 60,
+  "health_check_timeout": 20,
+  "permit_without_stream": false,
+  "initial_windows_size": 0
+}
+```
+
+> `authority`: string
+
+A string. Can be used as Host to achieve some other purposes.
+
+> `serviceName`: string
+
+A string. Specifies the service name, **similar to** Path in HTTP/2.
+The client uses this name for communication, and the server verifies if the service name matches.
+
+::: tip
+When `serviceName` starts with a slash, you can customize the path. It requires at least two slashes.<br>
+For example, fill in `"serviceName": "/my/sample/path1|path2"` on the server side, and the client can fill in `"serviceName": "/my/sample/path1"` or `"/my/sample/path2"`.
+:::
+
+> `user_agent`: string
+
+::: tip
+**Only** needs to be configured on **outbound** (**client**).
+:::
+
+Set the User-Agent for gRPC. This may prevent some CDNs from blocking gRPC traffic.
+
+> `multiMode`: true | false <Badge text="BETA" type="warning"/>
+
+`true` enables `multiMode`. Default value: `false`.
+
+This is an **experimental** option. It may not be kept long-term and cross-version compatibility is not guaranteed. This mode can bring about a 20% performance improvement in **test environments**, but actual results vary depending on transfer rates.
+
+::: tip
+**Only** needs to be configured on **outbound** (**client**).
+:::
+
+> `idle_timeout`: number
+
+Unit: seconds. When there is no data transmission during this period, a health check will be performed. If this value is set below `10`, `10` will be used (the minimum value).
+
+::: tip
+If you are not using reverse proxy tools like Caddy or Nginx (**usually not**), and set this below `60`, the server might send unexpected h2 GOAWAY frames to close existing connections.
+:::
+
+Health checks are **disabled** by default.
+
+::: tip
+**Only** needs to be configured on **outbound** (**client**).
+:::
+
+::: tip
+May resolve some "disconnection" issues.
+:::
+
+> `health_check_timeout`: number
+
+Unit: seconds. The timeout for health checks. If the health check is not completed within this time, and there is still no data transmission, the health check is considered failed. Default value is `20`.
+
+::: tip
+**Only** needs to be configured on **outbound** (**client**).
+:::
+
+> `permit_without_stream`: true | false
+
+`true` allows health checks when there are no sub-connections (streams). Default value is `false`.
+
+::: tip
+**Only** needs to be configured on **outbound** (**client**).
+:::
+
+> `initial_windows_size`: number
+
+Initial window size for h2 Stream. When the value is less than or equal to `0`, this feature does not take effect. When the value is greater than `65535`, the Dynamic Window mechanism will be disabled. Default value is `0` (disabled).
+
+::: tip
+**Only** needs to be configured on **outbound** (**client**).
+:::
+
+::: tip
+When going through Cloudflare CDN, you can set the value to `65536` or higher (disabling Dynamic Window) to prevent Cloudflare CDN from sending unexpected h2 GOAWAY frames to close existing connections.
+:::

package/data/docs/transports__transports_h2.md

@@ -0,0 +1,11 @@
+---
+url: https://xtls.github.io/en/config/transports/h2.html
+source_url: https://raw.githubusercontent.com/XTLS/Xray-docs-next/main/docs/en/config/transports/h2.md
+title: HTTP/2
+category: transports
+slug: transports/h2
+fetched_at: 2026-05-04T18:43:05.840Z
+---
+# HTTP/2
+
+See [XHTTP: Beyond REALITY](https://github.com/XTLS/Xray-core/discussions/4113)

package/data/docs/transports__transports_http.md

@@ -0,0 +1,11 @@
+---
+url: https://xtls.github.io/en/config/transports/http.html
+source_url: https://raw.githubusercontent.com/XTLS/Xray-docs-next/main/docs/en/config/transports/http.md
+title: HTTP
+category: transports
+slug: transports/http
+fetched_at: 2026-05-04T18:43:06.340Z
+---
+# HTTP
+
+See [XHTTP: Beyond REALITY](https://github.com/XTLS/Xray-core/discussions/4113)

package/data/docs/transports__transports_httpupgrade.md

@@ -0,0 +1,61 @@
+---
+url: https://xtls.github.io/en/config/transports/httpupgrade.html
+source_url: https://raw.githubusercontent.com/XTLS/Xray-docs-next/main/docs/en/config/transports/httpupgrade.md
+title: HTTPUpgrade
+category: transports
+slug: transports/httpupgrade
+fetched_at: 2026-05-04T18:43:04.806Z
+---
+# HTTPUpgrade
+
+A protocol that implements HTTP 1.1 upgrade requests and responses similar to WebSocket. This allows it to be reverse-proxied by CDNs or Nginx just like WebSocket, but without the need to implement other parts of the WebSocket protocol, resulting in higher efficiency.
+Its design is not recommended for standalone use; instead, it is intended to work with security protocols like TLS.
+
+::: danger
+**It is recommended to switch to [XHTTP](https://github.com/XTLS/Xray-core/discussions/4113) to avoid significant traffic fingerprints such as HTTPUpgrade's "ALPN is http/1.1".**
+:::
+
+## HttpUpgradeObject
+
+`HttpUpgradeObject` corresponds to the `httpupgradeSettings` item in transport configuration.
+
+```json
+{
+  "acceptProxyProtocol": false,
+  "path": "/",
+  "host": "xray.com",
+  "headers": {
+    "key": "value"
+  }
+}
+```
+
+> `acceptProxyProtocol`: true | false
+
+Only used for inbound; indicates whether to accept PROXY protocol.
+
+[PROXY protocol](https://www.haproxy.org/download/2.2/doc/proxy-protocol.txt) is dedicated to passing the real source IP and port of the request. **If you don't know what it is, please ignore this item for now.**
+
+Common reverse proxy software (such as HAProxy, Nginx) can be configured to send it. VLESS fallbacks xver can also send it.
+
+When set to `true`, after the underlying TCP connection is established, the requester must send PROXY protocol v1 or v2 first; otherwise, the connection will be closed.
+
+> `path`: string
+
+The HTTP path used by HTTPUpgrade. Default value is `"/"`.
+
+If the client path contains the `ed` parameter (e.g., `/mypath?ed=2560`), `Early Data` will be enabled to reduce latency. The value represents the threshold for the first packet length. If the first packet length exceeds this value, `Early Data` will not be enabled. The recommended value is 2560.
+
+> `host`: string
+
+The host sent in the HTTP request of HTTPUpgrade. Default value is empty. If the server-side value is empty, the host value sent by the client is not verified.
+
+When this value is specified on the server, or specified in `headers`, it will verify whether it is consistent with the host requested by the client.
+
+Priority of the host sent by the client: `host` > `headers` > `address`
+
+> `headers`: map \{string: string\}
+
+Client-only. Custom HTTP headers. A key-value pair, where each key represents the name of an HTTP header, and the corresponding value is a string.
+
+Default value is empty.

package/data/docs/transports__transports_hysteria.md

@@ -0,0 +1,110 @@
+---
+url: https://xtls.github.io/en/config/transports/hysteria.html
+source_url: https://raw.githubusercontent.com/XTLS/Xray-docs-next/main/docs/en/config/transports/hysteria.md
+title: Hysteria
+category: transports
+slug: transports/hysteria
+fetched_at: 2026-05-04T18:43:05.303Z
+---
+# Hysteria
+
+Xray implementation of the underlying QUIC transport for Hysteria2, typically used with hysteria [outbound](../outbounds/hysteria.md) and hysteria [inbound](../inbounds/hysteria.md), and is compatible with the official implementation in this case.
+
+## HysteriaObject
+
+`HysteriaObject` corresponds to the `hysteriaSettings` item in the transport configuration.
+
+```json
+{
+  "version": 2,
+  "auth": "password",
+  "udpIdleTimeout": 60,
+  "masquerade": {
+    "type": "",
+
+    "dir": "",
+
+    "url": "",
+    "rewriteHost": false,
+    "insecure": false,
+
+    "content": "",
+    "headers": {
+      "key": "value"
+    },
+    "statusCode": 0
+  }
+}
+```
+
+> `version`: number
+
+Hysteria version, must be 2.
+
+> `auth`: string
+
+Hysteria authentication password. Must be consistent between the server and the client.
+
+When used with `hysteria inbound`, it will be overridden by `clients` (if it exists).
+
+> `udpIdleTimeout`: number
+
+Unit: seconds, default 60.
+
+Idle wait time for a single `quic native udp` connection. If this time is too long, it may not be strictly adhered to and may be terminated by the policy first.
+
+> `masquerade`: [MasqObject](#MasqObject)
+
+HTTP/3 page masquerading.
+
+### MasqObject
+
+```json
+{
+  "type": "",
+
+  "dir": "",
+
+  "url": "",
+  "rewriteHost": false,
+  "insecure": false,
+
+  "content": "",
+  "headers": {
+    "key": "value"
+  },
+  "statusCode": 0
+}
+```
+
+> `type`: "file" | "proxy" | "string"
+
+If left blank, the default 404 page will be displayed.
+
+> `dir`: string
+
+Configuration items when type is file.
+
+> `url`: string
+
+Configuration items when type is proxy.
+
+> `rewriteHost`: false | true
+
+Configuration items when type is proxy.
+
+> `insecure`: false | true
+
+Configuration items when type is proxy.
+
+> `content`: string
+
+Configuration items when type is string.
+
+> `headers`: map{ string, string }
+
+Configuration items when type is string.
+
+> `statusCode`: int
+
+Configuration items when type is string.

package/data/docs/transports__transports_index.md

@@ -0,0 +1,19 @@
+---
+url: https://xtls.github.io/en/config/transports/index.html
+source_url: https://raw.githubusercontent.com/XTLS/Xray-docs-next/main/docs/en/config/transports/index.md
+title: Xray Transport Layer
+category: transports
+slug: transports/index
+fetched_at: 2026-05-04T18:43:00.806Z
+---
+# Xray Transport Layer
+
+Xray supports the following transport layers:
+
+- [RAW](raw.md)
+- [XHTTP: Beyond REALITY](xhttp.md)
+- [mKCP](mkcp.md)
+- [gRPC](grpc.md)
+- [WebSocket](websocket.md)
+- [HTTPUpgrade](httpupgrade.md)
+- [Hysteria](hysteria.md)

package/data/docs/transports__transports_mkcp.md

@@ -0,0 +1,125 @@
+---
+url: https://xtls.github.io/en/config/transports/mkcp.html
+source_url: https://raw.githubusercontent.com/XTLS/Xray-docs-next/main/docs/en/config/transports/mkcp.md
+title: mKCP
+category: transports
+slug: transports/mkcp
+fetched_at: 2026-05-04T18:43:03.280Z
+---
+# mKCP
+
+mKCP uses UDP to simulate TCP connections.
+
+mKCP sacrifices bandwidth to reduce latency. To transmit the same amount of content, mKCP generally consumes more traffic than TCP.
+
+::: tip
+Please ensure that the firewall configuration on the host is correct.
+:::
+
+## KcpObject
+
+`KcpObject` corresponds to the `kcpSettings` item in the transport configuration.
+
+```json
+{
+  "mtu": 1350,
+  "tti": 20,
+  "uplinkCapacity": 5,
+  "downlinkCapacity": 20,
+  "congestion": false,
+  "readBufferSize": 1,
+  "writeBufferSize": 1
+}
+```
+
+::: TIP
+The `header` and `seed` fields have been removed. Please use [FinalMask](../transport.md#finalmaskobject) for configuration.
+
+Additionally, the previously default mKCP obfuscation has also been removed. To connect to a legacy server, you need to configure `mkcp-original` in FinalMask.
+:::
+
+> `mtu`: number
+
+Maximum Transmission Unit.
+Please select a value between 576 and 1460.
+
+The default value is `1350`.
+
+> `tti`: number
+
+Transmission Time Interval, in milliseconds (ms). mKCP will send data at this frequency.
+Please select a value between 10 and 100.
+
+The default value is `50`.
+
+> `uplinkCapacity`: number
+
+Uplink capacity, i.e., the maximum bandwidth used by the host to send data. The unit is MB/s. Note that it is Byte, not bit.
+Can be set to 0, representing a very small bandwidth.
+
+The default value is `5`.
+
+> `downlinkCapacity`: number
+
+Downlink capacity, i.e., the maximum bandwidth used by the host to receive data. The unit is MB/s. Note that it is Byte, not bit.
+Can be set to 0, representing a very small bandwidth.
+
+The default value is `20`.
+
+::: tip
+`uplinkCapacity` and `downlinkCapacity` determine the transmission speed of mKCP.
+Taking a client sending data as an example, the client's `uplinkCapacity` specifies the speed of sending data, while the server's `downlinkCapacity` specifies the speed of receiving data. The actual speed will be the smaller of the two values.
+
+It is recommended to set `downlinkCapacity` to a larger value, such as 100, and set `uplinkCapacity` to the actual network speed. When the speed is insufficient, you can gradually increase the value of `uplinkCapacity` until it is about twice the bandwidth.
+:::
+
+> `congestion`: true | false
+
+Whether to enable congestion control.
+
+When congestion control is enabled, Xray automatically monitors network quality. When packet loss is severe, it automatically reduces throughput; when the network is smooth, it appropriately increases throughput.
+
+The default value is `false`.
+
+> `readBufferSize`: number
+
+The read buffer size for a single connection, in MB.
+
+The default value is `2`.
+
+> `writeBufferSize`: number
+
+The write buffer size for a single connection, in MB.
+
+The default value is `2`.
+
+::: tip
+`readBufferSize` and `writeBufferSize` specify the memory size used by a single connection.
+When high-speed transmission is required, specifying larger `readBufferSize` and `writeBufferSize` will improve speed to a certain extent, but it will also use more memory.
+
+When the network speed does not exceed 20MB/s, the default value of 1MB can meet the demand; beyond that, you can appropriately increase the values of `readBufferSize` and `writeBufferSize`, and then manually balance the relationship between speed and memory.
+:::
+
+## Credits
+
+- [@skywind3000](https://github.com/skywind3000) Invented and implemented the KCP protocol.
+- [@xtaci](https://github.com/xtaci) Ported KCP from C implementation to Go.
+- [@xiaokangwang](https://github.com/xiaokangwang) Tested the integration of KCP with Xray and submitted the initial PR.
+
+## Improvements to the KCP Protocol
+
+### Smaller Protocol Header
+
+The native KCP protocol uses a fixed header of 24 bytes, while mKCP modifies this to 18 bytes for data packets and 16 bytes for acknowledgement (ACK) packets. Smaller headers help evade characteristic detection and increase transmission speed.
+
+Additionally, native KCP's single ACK packet can only acknowledge the receipt of one data packet. This means that when KCP needs to acknowledge the receipt of 100 data packets, it sends 24 _100 = 2400 bytes of data. This includes a large amount of repetitive header data, causing bandwidth waste. mKCP compresses multiple ACK packets; 100 ACK packets require only 16 + 2 + 100_ 4 = 418 bytes, which is equivalent to one-sixth of the native size.
+
+### ACK Packet Retransmission
+
+The native KCP protocol sends acknowledgement (ACK) packets only once. If an ACK packet is lost, it inevitably leads to data retransmission, causing unnecessary bandwidth waste. mKCP retransmits ACK packets at a certain frequency until the sender confirms receipt. The size of a single ACK packet is 22 bytes, which is much smaller than the cost of retransmitting a data packet of over 1000 bytes.
+
+### Connection State Control
+
+mKCP can effectively open and close connections. When the remote host actively closes the connection, the connection is released within two seconds; when the remote host disconnects, the connection is released within a maximum of 30 seconds.
+
+Native KCP does not support this scenario.

package/data/docs/transports__transports_quic.md

@@ -0,0 +1,11 @@
+---
+url: https://xtls.github.io/en/config/transports/quic.html
+source_url: https://raw.githubusercontent.com/XTLS/Xray-docs-next/main/docs/en/config/transports/quic.md
+title: QUIC
+category: transports
+slug: transports/quic
+fetched_at: 2026-05-04T18:43:06.851Z
+---
+# QUIC
+
+See [XHTTP: Beyond REALITY](https://github.com/XTLS/Xray-core/discussions/4113)

package/data/docs/transports__transports_raw.md

@@ -0,0 +1,156 @@
+---
+url: https://xtls.github.io/en/config/transports/raw.html
+source_url: https://raw.githubusercontent.com/XTLS/Xray-docs-next/main/docs/en/config/transports/raw.md
+title: RAW
+category: transports
+slug: transports/raw
+fetched_at: 2026-05-04T18:43:01.273Z
+---
+# RAW
+
+Renamed from the former TCP transport layer (as the original name was ambiguous), the outbound RAW transport layer directly sends TCP or UDP data wrapped by the proxy protocol. The core does not use other transport layers (such as [XHTTP](https://github.com/XTLS/Xray-core/discussions/4113)) to carry its traffic.
+
+It can be combined with various protocols in multiple modes.
+
+## RawObject
+
+`RawObject` corresponds to the `rawSettings` item in transport configuration.
+
+```json
+{
+  "acceptProxyProtocol": false,
+  "header": {
+    "type": "none"
+  }
+}
+```
+
+> `acceptProxyProtocol`: true | false
+
+Only used for inbound; indicates whether to accept PROXY protocol.
+
+[PROXY protocol](https://www.haproxy.org/download/2.2/doc/proxy-protocol.txt) is dedicated to passing the real source IP and port of the request. **If you don't know what it is, please ignore this item for now.**
+
+Common reverse proxy software (such as HAProxy, Nginx) can be configured to send it. VLESS fallbacks xver can also send it.
+
+When set to `true`, after the underlying TCP connection is established, the requester must send PROXY protocol v1 or v2 first; otherwise, the connection will be closed.
+
+Default value is `false`.
+
+> `header`: [NoneHeaderObject](#noneheaderobject) | [HttpHeaderobject](#httpheaderobject)
+
+Packet header obfuscation settings. Default value is `NoneHeaderObject`.
+
+::: tip
+HTTP obfuscation cannot be traffic-split by other HTTP servers (like Nginx), but can be split by VLESS fallbacks path.
+:::
+
+### NoneHeaderObject
+
+No obfuscation.
+
+```json
+{
+  "type": "none"
+}
+```
+
+> `type`: "none"
+
+Specifies no obfuscation.
+
+### HttpHeaderObject
+
+HTTP obfuscation configuration must be configured on the corresponding inbound and outbound connections simultaneously, and the content must be consistent.
+
+```json
+{
+  "type": "http",
+  "request": {},
+  "response": {}
+}
+```
+
+> `type`: "http"
+
+Specifies HTTP obfuscation.
+
+> `request`: [HTTPRequestObject](#httprequestobject)
+
+HTTP Request.
+
+> `response`: [HTTPResponseObject](#httpresponseobject)
+
+HTTP Response.
+
+#### HTTPRequestObject
+
+```json
+{
+  "version": "1.1",
+  "method": "GET",
+  "path": ["/"],
+  "headers": {
+    "Host": ["www.baidu.com", "www.bing.com"],
+    "User-Agent": [
+      "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36",
+      "Mozilla/5.0 (iPhone; CPU iPhone OS 10_0_2 like Mac OS X) AppleWebKit/601.1 (KHTML, like Gecko) CriOS/53.0.2785.109 Mobile/14A456 Safari/601.1.46"
+    ],
+    "Accept-Encoding": ["gzip, deflate"],
+    "Connection": ["keep-alive"],
+    "Pragma": "no-cache"
+  }
+}
+```
+
+> `version`: string
+
+HTTP version. Default value is `"1.1"`.
+
+> `method`: string
+
+HTTP method. Default value is `"GET"`.
+
+> `path`: \[ string \]
+
+Path, an array of strings. Default value is `["/"]`. When there are multiple values, one is randomly selected for each request.
+
+> `headers`: map{ string, \[ string \]}
+
+HTTP headers. A key-value pair, where each key represents the name of an HTTP header, and the corresponding value is an array.
+
+All keys will be attached to every request, and one corresponding value will be randomly selected. See the example above for default values.
+
+#### HTTPResponseObject
+
+```json
+{
+  "version": "1.1",
+  "status": "200",
+  "reason": "OK",
+  "headers": {
+    "Content-Type": ["application/octet-stream", "video/mpeg"],
+    "Transfer-Encoding": ["chunked"],
+    "Connection": ["keep-alive"],
+    "Pragma": "no-cache"
+  }
+}
+```
+
+> `version`: string
+
+HTTP version. Default value is `"1.1"`.
+
+> `status`: string
+
+HTTP status code. Default value is `"200"`.
+
+> `reason`: string
+
+HTTP status reason phrase. Default value is `"OK"`.
+
+> `headers`: map {string, \[ string \]}
+
+HTTP headers. A key-value pair, where each key represents the name of an HTTP header, and the corresponding value is an array.
+
+All keys will be attached to every request, and one corresponding value will be randomly selected. See the example above for default values.

package/data/docs/transports__transports_splithttp.md

@@ -0,0 +1,11 @@
+---
+url: https://xtls.github.io/en/config/transports/splithttp.html
+source_url: https://raw.githubusercontent.com/XTLS/Xray-docs-next/main/docs/en/config/transports/splithttp.md
+title: SplitHTTP
+category: transports
+slug: transports/splithttp
+fetched_at: 2026-05-04T18:43:02.788Z
+---
+# SplitHTTP
+
+See [XHTTP: Beyond REALITY](https://github.com/XTLS/Xray-core/discussions/4113)

package/data/docs/transports__transports_tcp.md

@@ -0,0 +1,11 @@
+---
+url: https://xtls.github.io/en/config/transports/tcp.html
+source_url: https://raw.githubusercontent.com/XTLS/Xray-docs-next/main/docs/en/config/transports/tcp.md
+title: TCP
+category: transports
+slug: transports/tcp
+fetched_at: 2026-05-04T18:43:01.793Z
+---
+# TCP
+
+See [RAW](./raw.md)