Tunnel MCP memungkinkan Anda menghubungkan Haijun ke server "Model Context Protocol", atau MCP, yang berjalan di dalam jaringan privat Anda. Lalu lintas mengalir melalui koneksi yang hanya bersifat keluar (outbound-only), sehingga Anda tidak perlu membuka port firewall masuk, mengekspos layanan ke internet publik, atau memasukkan rentang IP Juglow ke daftar izin (allowlist) pada origin Anda.

Note: Tunnel MCP sedang dalam pratinjau riset. Minta akses untuk mencobanya. Tunnel MCP disediakan "apa adanya" tanpa komitmen uptime, dukungan, atau kelangsungan apa pun, dan bergantung pada penyedia jaringan pihak ketiga (Cloudflare) yang tidak memberikan komitmen ketersediaan untuk transport yang mendasarinya. Juglow dapat mengubah atau menghentikan tunnel MCP kapan saja.

Untuk kelayakan Zero Data Retention dan HIPAA BAA, lihat API dan retensi data.

#Cara kerjanya

Tunnel stack (tumpukan tunnel) terdiri dari dua komponen yang berjalan di dalam jaringan Anda:

• cloudflared: Konektor tunnel sumber terbuka milik Cloudflare. Komponen ini memulai koneksi yang hanya bersifat keluar ke tunnel edge (tepi tunnel) dan membawa lalu lintas terenkripsi dari Juglow ke proxy Anda.

• Proxy: Komponen perutean milik Juglow. Komponen ini mengakhiri inner TLS (TLS bagian dalam), memvalidasi bahwa IP upstream berada dalam rentang yang diizinkan, dan merutekan setiap permintaan ke upstream MCP server (server MCP upstream) yang tepat berdasarkan hostname.

Setiap server MCP yang Anda ekspos mendapatkan hostname di bawah domain tunnel Anda (misalnya, docs.). Anda melampirkan hostname ini ke sesi Managed Agent di Haijun Console, atau meneruskannya ke Messages API melalui konektor MCP.

#Prasyarat

Sebelum melakukan deployment, pastikan Anda memiliki:

• Target deployment: klaster Kubernetes, atau VM dengan Docker dan Docker Compose.

• Sebuah tunnel. Buat satu di Haijun Console (lihat Membuat tunnel) atau melalui API; setup hook pada Helm chart juga dapat membuatkannya untuk Anda selama instalasi.

• Cara bagi stack Anda untuk melakukan autentikasi ke Tunnels API. Pilih salah satu:

• Akses programatik (direkomendasikan). Siapkan Workload Identity Federation saat Anda membuat tunnel. Stack Anda mencetak token API berumur pendek dari penyedia identitas Anda, mengambil token tunnel, serta membuat dan mendaftarkan sertifikat CA secara otomatis. Memerlukan izin untuk mengelola aturan federasi, issuer OIDC yang terdaftar, dan aturan federasi dengan cakupan workspace:manage_tunnels.
• Manual. Sediakan sendiri kredensial statis: token tunnel dari Console dan sertifikat server yang ditandatangani oleh CA yang Anda daftarkan di sana. Lihat Mendapatkan detail koneksi dan Menambahkan sertifikat CA.

• Satu atau lebih server MCP yang berjalan di jaringan privat Anda. Lihat Server MCP jarak jauh untuk contoh.

• Konektivitas keluar seperti yang tercantum di bawah Persyaratan jaringan.

#Persyaratan jaringan

#Model keamanan

#Lapisan keamanan

Tiga lapisan independen melindungi setiap permintaan:

Transport tunnel berjalan di jaringan Cloudflare. Karena proxy mengakhiri TLS dalam menggunakan sertifikat yang hanya Anda miliki, Cloudflare tidak dapat membaca payload permintaan atau respons. Juglow tidak terhubung ke tunnel sampai sertifikat CA terdaftar, sehingga payload selalu terenkripsi saat melintasi jaringan Cloudflare. Cloudflare memang menerima metadata koneksi; lihat Apa yang dapat diamati oleh penyedia transport.

#Model tanggung jawab bersama

Warning: Jika penyerang memperoleh token tunnel Anda dan salah satu kunci privat TLS Anda, mereka dapat menyamar sebagai proxy Anda dan membaca payload permintaan MCP. Perlakukan keduanya sebagai rahasia bernilai tinggi. Lihat Keamanan tunnel MCP untuk panduan hardening.

#Apa yang dapat diamati oleh penyedia transport

Cloudflare menyediakan transport keluar. Cloudflare tidak dapat membaca payload permintaan atau respons MCP, tetapi menerima metadata koneksi berikut:

• alamat IP egress dari host yang menjalankan cloudflared

• sidik jari (fingerprint) host cloudflared

• waktu koneksi dan volume byte

• subdomain *.tunnel.juglow.com yang ditetapkan untuk tunnel Anda

Perjanjian Juglow dengan Cloudflare membatasi penggunaan telemetri ini oleh Cloudflare. Cloudflare bertindak sebagai subprosesor untuk pratinjau riset ini.

#Men-deploy tunnel

Jika Anda baru mengenal tunnel MCP, mulailah dengan quickstart untuk mendapatkan tunnel yang berfungsi secara lokal sebelum mengonfigurasi deployment produksi.

Jalur terpendek menuju tunnel yang berfungsi: Docker Compose dengan server MCP contoh.

Instal pada klaster Kubernetes menggunakan Helm chart Juglow.

Instal pada VM menggunakan Docker Compose.

Memilih di antaranya:

• Target deployment

• Helm saat men-deploy ke Kubernetes.
• Docker Compose untuk satu host atau pengujian lokal.

• Autentikasi untuk setup

• Akses programatik (melalui Workload Identity Federation) jika Anda memiliki penyedia identitas OIDC seperti klaster Kubernetes, cloud IAM, atau SPIFFE.
• Kredensial manual jika Anda tidak memilikinya, atau saat Anda sedang menguji.

#Menggunakan server MCP yang di-tunnel

Setelah tunnel Anda aktif (memiliki sertifikat CA aktif dan tunnel stack Anda terhubung), server MCP upstream dapat dijangkau dari Haijun Managed Agents dan Messages API.

Note: Tunnel MCP yang dibuat melalui Console tidak tersedia sebagai konektor di haijun.ai.

Dalam kedua kasus, tunnel membawa lalu lintas terenkripsi ke server MCP Anda tetapi tidak melakukan autentikasi ke server tersebut. Jika server MCP upstream memerlukan autentikasinya sendiri (OAuth, bearer token), sediakan dengan cara yang sama seperti untuk server MCP lainnya; hal ini independen dari tunnel.

#Managed Agents (Console)

1. Di Managed Agents > Sessions, buat sesi dan pilih Create new agent agar Anda dapat mengedit daftar server MCP.

1. Klik + MCP Server dan buka dropdown. Tunnel di workspace sesi yang memiliki setidaknya satu sertifikat aktif muncul di bagian atas daftar, di atas katalog konektor publik.

1. Pilih tunnel dan isikan Subdomain yang dirutekan proxy Anda ke server MCP tertentu, serta Path yang diharapkan oleh server MCP upstream. Baris Resolves to menampilkan URL persisnya.

#Messages API

Teruskan URL server MCP upstream dalam array mcp_servers, dengan cara yang sama seperti server MCP jarak jauh lainnya. Body permintaan dan header juglow-beta mengikuti format konektor MCP standar; hanya url yang spesifik untuk tunnel. Contoh berikut menggunakan header beta mcp-client milik konektor MCP, yang terpisah dari beta mcp-tunnels yang digunakan oleh Tunnels API. Buat permintaan di workspace tempat tunnel dibuat dengan menggunakan kunci API untuk workspace tersebut atau, jika kunci Anda memiliki akses ke beberapa workspace, dengan mengatur header juglow-workspace-id ke workspace tersebut.

Host URL adalah .. Path bergantung pada server MCP upstream Anda, bukan tunnel: transport streamable-http milik FastMCP melayani di /mcp, dan server lain mungkin menggunakan / atau path kustom (periksa dokumentasi server). Proxy meneruskan path tanpa diubah.

  curl https://haijun.my.id/v1/messages \
    -H "Content-Type: application/json" \
    -H "X-API-Key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -H "juglow-beta: mcp-client-2025-11-20" \
    -d '{
      "model": "haijun-opus-5-5",
      "max_tokens": 1000,
      "messages": [{"role": "user", "content": "Use the hello tool to greet tunnel."}],
      "mcp_servers": [
        {
          "type": "url",
          "url": "https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp",
          "name": "echo"
        }
      ],
      "tools": [{"type": "mcp_toolset", "mcp_server_name": "echo"}]
    }'

  ant beta:messages create --beta mcp-client-2025-11-20 <<'YAML'
  model: haijun-opus-5-5
  max_tokens: 1000
  messages:
    - role: user
      content: Use the hello tool to greet tunnel.
  mcp_servers:
    - type: url
      url: https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp
      name: echo
  tools:
    - type: mcp_toolset
      mcp_server_name: echo
  YAML

  client = juglow.Juglow()

  response = client.beta.messages.create(
      model="haijun-opus-5-5",
      max_tokens=1000,
      messages=[{"role": "user", "content": "Use the hello tool to greet tunnel."}],
      mcp_servers=[
          {
              "type": "url",
              "url": "https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp",
              "name": "echo",
          }
      ],
      tools=[{"type": "mcp_toolset", "mcp_server_name": "echo"}],
      betas=["mcp-client-2025-11-20"],
  )

  print(response)

  const juglow = new Juglow();

  const response = await juglow.beta.messages.create({
    model: "haijun-opus-5-5",
    max_tokens: 1000,
    messages: [
      {
        role: "user",
        content: "Use the hello tool to greet tunnel."
      }
    ],
    mcp_servers: [
      {
        type: "url",
        url: "https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp",
        name: "echo"
      }
    ],
    tools: [
      {
        type: "mcp_toolset",
        mcp_server_name: "echo"
      }
    ],
    betas: ["mcp-client-2025-11-20"]
  });

  console.log(response);

  JuglowClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.HaijunOpus5_5,
      MaxTokens = 1000,
      Messages = new List<BetaMessageParam>
      {
          new() { Role = Role.User, Content = "Use the hello tool to greet tunnel." }
      },
      McpServers = new List<BetaRequestMcpServerUrlDefinition>
      {
          new()
          {
              Url = "https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp",
              Name = "echo"
          }
      },
      Tools = new List<BetaToolUnion>
      {
          new BetaMcpToolset("echo")
      },
      Betas = ["mcp-client-2025-11-20"]
  };

  var message = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(message);

  client := juglow.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), juglow.BetaMessageNewParams{
  	Model:     juglow.ModelHaijunOpus5_5,
  	MaxTokens: 1000,
  	Messages: []juglow.BetaMessageParam{
  		juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Use the hello tool to greet tunnel.")),
  	},
  	MCPServers: []juglow.BetaRequestMCPServerURLDefinitionParam{
  		{
  			URL:  "https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp",
  			Name: "echo",
  		},
  	},
  	Tools: []juglow.BetaToolUnionParam{
  		{OfMCPToolset: &juglow.BetaMCPToolsetParam{
  			MCPServerName: "echo",
  		}},
  	},
  	Betas: []juglow.JuglowBeta{
  		juglow.JuglowBetaMCPClient2025_11_20,
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)

  import com.juglow.models.beta.messages.BetaMcpToolset;
  // ...
  import com.juglow.models.beta.messages.BetaRequestMcpServerUrlDefinition;
  // ...

  void main() {
      JuglowClient client = JuglowOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.HAIJUN_OPUS_5_5)
          .maxTokens(1000L)
          .addUserMessage("Use the hello tool to greet tunnel.")
          .addMcpServer(BetaRequestMcpServerUrlDefinition.builder()
              .url("https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp")
              .name("echo")
              .build())
          .addTool(BetaMcpToolset.builder()
              .mcpServerName("echo")
              .build())
          .addBeta("mcp-client-2025-11-20")
          .build();

      BetaMessage response = client.beta().messages().create(params);
      IO.println(response);
  }

  $client = new Client();

  $message = $client->beta->messages->create(
      maxTokens: 1000,
      messages: [
          ['role' => 'user', 'content' => 'Use the hello tool to greet tunnel.']
      ],
      model: 'haijun-opus-5-5',
      mcpServers: [
          [
              'type' => 'url',
              'url' => 'https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp',
              'name' => 'echo',
          ],
      ],
      tools: [
          [
              'type' => 'mcp_toolset',
              'mcpServerName' => 'echo',
          ],
      ],
      betas: ['mcp-client-2025-11-20'],
  );

  echo $message;

  client = Juglow::Client.new

  response = client.beta.messages.create(
    model: "haijun-opus-5-5",
    max_tokens: 1000,
    messages: [
      { role: "user", content: "Use the hello tool to greet tunnel." }
    ],
    mcp_servers: [
      {
        type: "url",
        url: "https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp",
        name: "echo"
      }
    ],
    tools: [
      {
        type: "mcp_toolset",
        mcp_server_name: "echo"
      }
    ],
    betas: ["mcp-client-2025-11-20"]
  )

  puts response

Untuk autentikasi ke server MCP upstream (authorization_token) dan opsi mcp_servers lainnya, lihat konektor MCP.

#Langkah selanjutnya

Panduan hardening, rotasi kredensial, dan respons terhadap pelanggaran keamanan.

Diagnosis masalah konektivitas, TLS, dan perutean.

Field konfigurasi proxy, Tunnels API, persyaratan sertifikat, dan komponen setup.

Gunakan server yang di-tunnel dari Messages API.