> ## Documentation Index > Fetch the complete documentation index at: https://cli.fuxicode.com/docs/llms.txt > Use this file to discover all available pages before exploring further. # Hubungkan Fuxi Code ke alat melalui MCP > Pelajari cara menghubungkan Fuxi Code ke alat Anda dengan Model Context Protocol. Fuxi Code dapat terhubung ke ratusan alat eksternal dan sumber data melalui [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction), standar sumber terbuka untuk integrasi AI-alat. Server MCP memberikan Fuxi Code akses ke alat, database, dan API Anda. Hubungkan server ketika Anda menemukan diri Anda menyalin data ke dalam chat dari alat lain, seperti pelacak masalah atau dasbor pemantauan. Setelah terhubung, Fuxi dapat membaca dan bertindak pada sistem tersebut secara langsung alih-alih bekerja dari apa yang Anda tempel. Jika Anda menghubungkan server pertama Anda, mulai dengan [panduan cepat MCP](/id/mcp-quickstart) untuk panduan langkah demi langkah. Halaman ini adalah referensi lengkap.

Apa yang dapat Anda lakukan dengan MCP

Dengan server MCP yang terhubung, Anda dapat meminta Fuxi Code untuk: * **Menerapkan fitur dari pelacak masalah**: "Tambahkan fitur yang dijelaskan dalam masalah JIRA ENG-4521 dan buat PR di GitHub." * **Menganalisis data pemantauan**: "Periksa Sentry dan Statsig untuk memeriksa penggunaan fitur yang dijelaskan dalam ENG-4521." * **Menanyakan database**: "Temukan email 10 pengguna acak yang menggunakan fitur ENG-4521, berdasarkan database PostgreSQL kami." * **Mengintegrasikan desain**: "Perbarui template email standar kami berdasarkan desain Figma baru yang diposting di Slack" * **Mengotomatisasi alur kerja**: "Buat draf Gmail mengundang 10 pengguna ini ke sesi umpan balik tentang fitur baru." * **Bereaksi terhadap peristiwa eksternal**: Server MCP juga dapat bertindak sebagai [saluran](/id/channels) yang mendorong pesan ke dalam sesi Anda, sehingga Fuxi bereaksi terhadap pesan Telegram, obrolan Discord, atau peristiwa webhook saat Anda sedang pergi.

Temukan dan bangun server MCP

Jelajahi konektor yang telah ditinjau di [Direktori Anthropic](https://fuxi.ai/directory). Konektor Direktori menggunakan infrastruktur MCP yang sama dengan Fuxi Code, jadi Anda dapat menambahkan server jarak jauh apa pun yang terdaftar di sana dengan `fuxi mcp add`. Verifikasi bahwa Anda mempercayai setiap server sebelum menghubungkannya. Server yang mengambil konten eksternal dapat mengekspos Anda ke [risiko injeksi prompt](/id/security#protect-against-prompt-injection). Untuk membangun server Anda sendiri, lihat [panduan server MCP](https://modelcontextprotocol.io/docs/develop/build-server) untuk dasar-dasar protokol dan [dokumentasi pembangun konektor Fuxi](https://fuxi.com/docs/connectors/building) untuk autentikasi, pengujian, dan pengajuan Direktori. Anda juga dapat membuat Fuxi membangun server untuk Anda dengan plugin resmi [`mcp-server-dev`](https://github.com/anthropics/fuxi-plugins-official/tree/main/plugins/mcp-server-dev). Dalam sesi Fuxi Code, jalankan: ``` /plugin install mcp-server-dev@fuxi-plugins-official ``` Jika Fuxi Code melaporkan bahwa marketplace tidak ditemukan, jalankan `/plugin marketplace add anthropics/fuxi-plugins-official` terlebih dahulu, kemudian coba lagi instalnya. Setelah diinstal, jalankan `/reload-plugins` untuk mengaktifkannya dalam sesi saat ini. ``` /mcp-server-dev:build-mcp-server ``` Fuxi menanyakan tentang kasus penggunaan Anda dan membangun server HTTP jarak jauh atau server stdio lokal.

Menginstal server MCP

Server MCP dapat dikonfigurasi dengan beberapa cara berbeda tergantung pada kebutuhan Anda:

Opsi 1: Tambahkan server HTTP jarak jauh

Server HTTP adalah opsi yang direkomendasikan untuk terhubung ke server MCP jarak jauh. Ini adalah transport yang paling banyak didukung untuk layanan berbasis cloud. ```bash theme={null} # Sintaks dasar fuxi mcp add --transport http # Contoh nyata: Hubungkan ke Notion fuxi mcp add --transport http notion https://mcp.notion.com/mcp # Contoh dengan token Bearer fuxi mcp add --transport http secure-api https://api.example.com/mcp \ --header "Authorization: Bearer your-token" ``` Saat mengonfigurasi server MCP melalui JSON dalam `.mcp.json`, `~/.fuxi.json`, atau `fuxi mcp add-json`, bidang `type` menerima `streamable-http` sebagai alias untuk `http`. Spesifikasi MCP menggunakan nama `streamable-http` untuk transport ini, jadi konfigurasi yang disalin dari dokumentasi server berfungsi tanpa modifikasi. Entri JSON yang memiliki `url` tetapi tidak ada `type` adalah kesalahan konfigurasi, karena Fuxi Code membaca entri tanpa `type` sebagai server stdio. Fuxi Code melewati server tersebut dan melaporkan `MCP server "" has a "url" but no "type"; add "type": "http" (or "sse" / "ws") to this entry`. Sebelum v2.1.202, Fuxi Code melaporkan kesalahan konfigurasi ini sebagai `command: expected string, received undefined`.

Opsi 2: Tambahkan server SSE jarak jauh

Transport SSE (Server-Sent Events) sudah usang. Gunakan server HTTP sebagai gantinya, jika tersedia. ```bash theme={null} # Sintaks dasar fuxi mcp add --transport sse # Contoh nyata: Hubungkan ke Asana fuxi mcp add --transport sse asana https://mcp.asana.com/sse # Contoh dengan header autentikasi fuxi mcp add --transport sse private-api https://api.company.com/sse \ --header "X-API-Key: your-key-here" ```

Opsi 3: Tambahkan server stdio lokal

Server stdio berjalan sebagai proses lokal di mesin Anda. Mereka ideal untuk alat yang memerlukan akses sistem langsung atau skrip khusus. Fuxi Code menetapkan `FUXI_PROJECT_DIR` di lingkungan server yang dihasilkan ke akar proyek, sehingga server Anda dapat menyelesaikan jalur relatif proyek tanpa bergantung pada direktori kerja. Ini adalah direktori yang sama yang diterima hooks dalam variabel `FUXI_PROJECT_DIR` mereka. Bacalah dari dalam proses server Anda, misalnya `process.env.FUXI_PROJECT_DIR` di Node atau `os.environ["FUXI_PROJECT_DIR"]` di Python. `FUXI_PROJECT_DIR` adalah akar proyek yang stabil dan tidak berubah ketika Anda menambah atau menghapus direktori kerja di tengah sesi. Server yang membatasi akses sistem file-nya sendiri ke serangkaian direktori yang diizinkan harus mengimplementasikan permintaan MCP `roots/list` sebagai gantinya. Fuxi Code menjawab `roots/list` dengan direktori peluncuran sesi ditambah setiap [direktori kerja tambahan](/id/permissions#working-directories) yang telah Anda berikan dengan `--add-dir`, `/add-dir`, atau pengaturan `additionalDirectories`. Fuxi Code mengirim `notifications/roots/list_changed` ketika set tersebut berubah. Sebelum v2.1.203, `roots/list` hanya mengembalikan direktori peluncuran dan Fuxi Code tidak mengirim `notifications/roots/list_changed`. Variabel ini ditetapkan di lingkungan server, bukan di lingkungan Fuxi Code itu sendiri, jadi mereferensikannya melalui ekspansi `${VAR}` dalam `.mcp.json` yang bersifat proyek atau pengguna `command` atau `args` memerlukan default seperti `${FUXI_PROJECT_DIR:-.}`. Konfigurasi MCP yang disediakan plugin mengganti `${FUXI_PROJECT_DIR}` secara langsung dan tidak memerlukan default. ```bash theme={null} # Sintaks dasar fuxi mcp add [options] -- [args...] # Contoh nyata: Tambahkan server Airtable fuxi mcp add --env AIRTABLE_API_KEY=YOUR_KEY --transport stdio airtable \ -- npx -y airtable-mcp-server ``` **Penting: Pisahkan argumen server dengan `--`** Untuk server stdio, `--` (tanda hubung ganda) memisahkan opsi Fuxi sendiri, seperti `--transport`, `--env`, dan `--scope`, dari perintah dan argumen yang menjalankan server. Semuanya setelah `--` diteruskan ke server tanpa diubah. Sebagai contoh: * `fuxi mcp add --transport stdio myserver -- npx server` → menjalankan `npx server` * `fuxi mcp add --env KEY=value --transport stdio myserver -- python server.py --port 8080` → menjalankan `python server.py --port 8080` dengan `KEY=value` di lingkungan Tanpa `--`, Fuxi Code akan mencoba mengurai flag server, seperti `--port` di atas, sebagai opsinya sendiri. `--env` menerima beberapa pasangan `KEY=value`. Jika nama server datang langsung setelah `--env`, CLI membaca nama sebagai pasangan lain dan menolaknya, jadi tempatkan setidaknya satu opsi lain antara `--env` dan nama server, seperti dalam contoh di atas.

Opsi 4: Tambahkan server WebSocket jarak jauh

Server WebSocket mempertahankan koneksi bidirectional yang persisten, yang cocok untuk server MCP jarak jauh yang mendorong peristiwa ke Fuxi tanpa diminta. Gunakan HTTP sebagai gantinya ketika server Anda hanya merespons permintaan, karena HTTP mendukung OAuth dan flag `fuxi mcp add --transport`, sementara WebSocket tidak mendukung keduanya. Konfigurasi server WebSocket dalam `.mcp.json` atau dengan `fuxi mcp add-json`: ```bash theme={null} fuxi mcp add-json events-server \ '{"type":"ws","url":"wss://mcp.example.com/socket","headers":{"Authorization":"Bearer YOUR_TOKEN"}}' ``` Entri `type: "ws"` menerima bidang `url`, `headers`, `headersHelper`, `timeout`, dan `alwaysLoad` yang sama seperti `http`. Autentikasi hanya header, jadi teruskan token statis dalam `headers` atau buat satu pada waktu koneksi dengan [`headersHelper`](#use-dynamic-headers-for-custom-authentication). Flag `fuxi mcp add --transport` tidak menerima `ws`.

Mengelola server Anda

Setelah dikonfigurasi, Anda dapat mengelola server MCP Anda dengan perintah ini: ```bash theme={null} # Daftar semua server yang dikonfigurasi fuxi mcp list # Dapatkan detail untuk server tertentu fuxi mcp get github # Hapus server fuxi mcp remove github # (dalam Fuxi Code) Periksa status server /mcp ``` Server yang bersifat proyek dari `.mcp.json` yang menunggu persetujuan Anda muncul dalam `fuxi mcp list` sebagai `⏸ Pending approval`. Jalankan `fuxi` secara interaktif untuk meninjau dan menyetujui mereka. `fuxi mcp get ` menampilkan server yang tertunda sebagai `⏸ Pending approval` dan server yang ditolak sebagai `✗ Rejected`. Mulai dari v2.1.196, `fuxi mcp list` dan `fuxi mcp get` membaca persetujuan `.mcp.json` hanya dari file pengaturan yang tidak dimasukkan ke dalam repositori sampai Anda mempercayai workspace dengan menjalankan `fuxi` di dalamnya dan menerima dialog kepercayaan workspace. Repositori yang diklon tidak dapat menyetujui server-nya sendiri: [`enableAllProjectMcpServers` atau `enabledMcpjsonServers`](/id/settings#available-settings) yang dikomitkan ke `.fuxi/settings.json` proyek diabaikan dalam folder yang tidak dipercaya, dan server tetap di `⏸ Pending approval` alih-alih terhubung dan diperiksa kesehatannya. Persetujuan dari sumber-sumber ini masih berlaku dalam folder yang tidak dipercaya: * `~/.fuxi/settings.json` pengguna Anda * pengaturan yang dikelola * pengaturan yang diteruskan dengan `--settings` * `.fuxi/settings.local.json`, selama git tidak melacaknya Entri `disabledMcpjsonServers` dalam file pengaturan apa pun masih menolak server. Panel `/mcp` menampilkan jumlah alat di sebelah setiap server yang terhubung dan menandai server yang mengiklankan kemampuan alat tetapi tidak mengekspos alat apa pun. Jika permintaan Anda memerlukan alat dari server yang masih terhubung di latar belakang, Fuxi menunggu server tersebut sebelum melanjutkan. Dengan [pencarian alat](#scale-with-mcp-tool-search) diaktifkan, yang merupakan default, penantian terjadi di dalam panggilan `ToolSearch`. Dalam konfigurasi tanpa pencarian alat, seperti Platform Agen Google Cloud, `ANTHROPIC_BASE_URL` khusus, atau `ENABLE_TOOL_SEARCH=false`, Fuxi menggunakan alat `WaitForMcpServers` sebagai gantinya. Beberapa nama server dicadangkan untuk server bawaan Fuxi Code: `workspace`, `fuxi-in-chrome`, `computer-use`, `Fuxi Preview`, dan `Fuxi Browser`. Jika konfigurasi Anda menentukan server dengan nama yang dicadangkan, Fuxi Code melewatinya saat waktu muat dan menampilkan peringatan yang meminta Anda untuk mengganti namanya. `fuxi mcp add` menolak nama yang dicadangkan dengan kesalahan. `Fuxi Preview` dan `Fuxi Browser` keduanya menamai server bawaan yang digunakan oleh [panel pratinjau aplikasi desktop Fuxi Code](/id/desktop#preview-your-app). Sebelum v2.1.205, `Fuxi Browser` tidak dicadangkan, jadi server yang dikonfigurasi pengguna dapat terdaftar di bawah nama tersebut.

Pembaruan alat dinamis

Fuxi Code mendukung notifikasi `list_changed` MCP, memungkinkan server MCP untuk secara dinamis memperbarui alat, prompt, dan sumber daya yang tersedia tanpa memerlukan Anda untuk memutuskan dan menghubungkan kembali. Ketika server MCP mengirim notifikasi `list_changed`, Fuxi Code secara otomatis menyegarkan kemampuan yang tersedia dari server tersebut.

Koneksi ulang otomatis

Jika server HTTP atau SSE terputus di tengah sesi, Fuxi Code secara otomatis menghubungkan kembali dengan backoff eksponensial: hingga lima upaya, dimulai dengan penundaan satu detik dan berlipat ganda setiap kali. Server muncul sebagai tertunda dalam `/mcp` saat koneksi ulang sedang berlangsung. Setelah lima upaya gagal, server ditandai sebagai gagal dan Anda dapat mencoba lagi secara manual dari `/mcp`. Server stdio adalah proses lokal dan tidak dihubungkan kembali secara otomatis. Backoff yang sama berlaku ketika server HTTP atau SSE gagal koneksi awalnya saat startup. Mulai dari v2.1.121, Fuxi Code mencoba ulang koneksi awal hingga tiga kali pada kesalahan transien seperti respons 5xx, koneksi ditolak, atau timeout, kemudian menandai server sebagai gagal jika masih tidak dapat terhubung. Kesalahan autentikasi dan not-found tidak dicoba ulang karena memerlukan perubahan konfigurasi untuk diselesaikan. Ketika server yang dikonfigurasi gagal terhubung, Fuxi Code memberi tahu Fuxi server mana yang gagal dan kesalahan koneksinya, termasuk dalam hasil `ToolSearch` yang tidak menemukan alat yang cocok, sehingga Fuxi melaporkan kegagalan koneksi dalam responsnya. Memerlukan [pencarian alat](#scale-with-mcp-tool-search), yang diaktifkan secara default. Dalam konfigurasi tanpa pencarian alat, seperti `ANTHROPIC_BASE_URL` khusus, `ENABLE_TOOL_SEARCH=false`, atau model Haiku, dan di Amazon Bedrock, Platform Agen Google Cloud, dan Microsoft Foundry, Fuxi Code tidak melaporkan kegagalan koneksi server yang gagal kepada Fuxi. Sebelum v2.1.205, Fuxi Code tidak meneruskan kesalahan koneksi kepada Fuxi, dan Fuxi dapat merespons seolah-olah alat server yang gagal tidak pernah dikonfigurasi. Mulai dari v2.1.191, permintaan penemuan kemampuan yang berjalan setelah koneksi yang berhasil, seperti `tools/list`, `prompts/list`, dan `resources/list`, juga mencoba ulang kesalahan jaringan transien dan server hingga tiga kali dengan backoff pendek. Kesalahan autentikasi, respons 4xx, dan timeout permintaan tidak dicoba ulang.

Dorong pesan dengan saluran

Server MCP juga dapat mendorong pesan langsung ke dalam sesi Anda sehingga Fuxi dapat bereaksi terhadap peristiwa eksternal seperti hasil CI, peringatan pemantauan, atau pesan obrolan. Untuk mengaktifkan ini, server Anda mendeklarasikan kemampuan `fuxi/channel` dan Anda memilihnya dengan flag `--channels` saat startup. Lihat [Saluran](/id/channels) untuk menggunakan saluran yang didukung secara resmi, atau [Referensi saluran](/id/channels-reference) untuk membangun saluran Anda sendiri. Tips: * Gunakan flag `-s` atau `--scope` untuk menentukan di mana konfigurasi disimpan: * `local` (default): Hanya tersedia untuk Anda di proyek saat ini. Versi yang lebih lama menyebut cakupan ini `project` * `project`: Dibagikan dengan semua orang di proyek melalui file `.mcp.json` * `user`: Tersedia untuk Anda di semua proyek. Versi yang lebih lama menyebut cakupan ini `global` * Atur variabel lingkungan dengan flag `-e` atau `--env` (misalnya, `-e KEY=value`) * Flag `--transport` dan `--header` juga menerima bentuk pendek `-t` dan `-H` * Konfigurasi waktu tunggu startup server MCP menggunakan variabel lingkungan `MCP_TIMEOUT` (misalnya, `MCP_TIMEOUT=10000 fuxi` menetapkan waktu tunggu 10 detik) * Atur waktu tunggu eksekusi alat per-server dengan menambahkan bidang `timeout` dalam milidetik ke entri `.mcp.json` server tersebut, misalnya `"timeout": 600000` untuk sepuluh menit. Ini menggantikan variabel lingkungan `MCP_TOOL_TIMEOUT` hanya untuk server tersebut * Fuxi Code menampilkan peringatan ketika output alat MCP melebihi 10.000 token. Untuk meningkatkan batas ini, atur variabel lingkungan `MAX_MCP_OUTPUT_TOKENS` (misalnya, `MAX_MCP_OUTPUT_TOKENS=50000`) * Gunakan `/mcp` untuk autentikasi dengan server jarak jauh yang memerlukan autentikasi OAuth 2.0 Waktu tunggu per-server `timeout` adalah batas dinding jam yang keras per panggilan alat, dan notifikasi kemajuan dari server tidak memperpanjangnya. Nilai di bawah 1000 diabaikan dan jatuh melalui `MCP_TOOL_TIMEOUT`, atau ke default-nya sekitar 28 jam ketika variabel tersebut tidak diatur. {/* min-version: 2.1.162 */}Sebelum v2.1.162, nilai di bawah 1000 dibulatkan ke satu detik sebagai gantinya. Waktu tunggu per-server `timeout` setidaknya 1000 juga bertindak sebagai lantai pada timeout idle yang dijelaskan di bawah: Fuxi Code tidak pernah membatalkan panggilan alat server tersebut karena menganggur lebih cepat daripada waktu tunggu per-server `timeout`. Memerlukan Fuxi Code v2.1.203 atau lebih baru. Untuk server HTTP dan SSE, anggaran first-byte fetch per-permintaan memiliki minimum 60 detik. Panggilan alat ke server MCP yang tidak mengirim respons dan tidak ada notifikasi kemajuan untuk jendela idle akan dibatalkan dengan kesalahan alih-alih menunggu batas dinding jam. Timeout idle memerlukan Fuxi Code v2.1.187 atau lebih baru. {/* min-version: 2.1.203 */}Ini berlaku untuk setiap jenis server kecuali server IDE dan server in-process SDK. Jendela idle default ke lima menit untuk HTTP, SSE, WebSocket, dan server [konektor fuxi.ai](#use-mcp-servers-from-fuxi-ai), dan ke 30 menit untuk server stdio. Sebelum v2.1.203, server stdio dikecualikan dari timeout idle. Atur variabel lingkungan [`FUXI_CODE_MCP_TOOL_IDLE_TIMEOUT`](/id/env-vars) dalam milidetik untuk mengubah jendela idle, atau atur ke `0` untuk menonaktifkan pemeriksaan.

Server MCP yang disediakan plugin

[Plugin](/id/plugins) dapat menggabungkan server MCP, secara otomatis menyediakan alat dan integrasi ketika plugin diaktifkan. Server MCP plugin bekerja identik dengan server yang dikonfigurasi pengguna. **Cara kerja server MCP plugin**: * Plugin menentukan server MCP dalam `.mcp.json` di root plugin atau inline dalam `plugin.json` * Ketika plugin diaktifkan, server MCP-nya dimulai secara otomatis * Alat MCP plugin muncul bersama alat MCP yang dikonfigurasi secara manual * Server plugin dikelola melalui instalasi plugin, bukan perintah `/mcp` **Contoh konfigurasi MCP plugin**: Dalam `.mcp.json` di root plugin: ```json theme={null} { "mcpServers": { "database-tools": { "command": "${FUXI_PLUGIN_ROOT}/servers/db-server", "args": ["--config", "${FUXI_PLUGIN_ROOT}/config.json"], "env": { "DB_URL": "${DB_URL}" } } } } ``` Atau inline dalam `plugin.json`: ```json theme={null} { "name": "my-plugin", "mcpServers": { "plugin-api": { "command": "${FUXI_PLUGIN_ROOT}/servers/api-server", "args": ["--port", "8080"] } } } ``` **Fitur MCP plugin**: * **Siklus hidup otomatis**: Pada startup sesi, server untuk plugin yang diaktifkan terhubung secara otomatis. Jika Anda mengaktifkan atau menonaktifkan plugin selama sesi, jalankan `/reload-plugins` untuk menghubungkan atau memutuskan server MCP-nya * **Variabel lingkungan**: gunakan `${FUXI_PLUGIN_ROOT}` untuk file plugin bundel, `${FUXI_PLUGIN_DATA}` untuk [status persisten](/id/plugins-reference#persistent-data-directory) yang bertahan pembaruan plugin, dan `${FUXI_PROJECT_DIR}` untuk akar proyek yang stabil * **Akses lingkungan pengguna**: Akses ke variabel lingkungan yang sama seperti server yang dikonfigurasi secara manual * **Jenis transport berganda**: Dukungan transport stdio, SSE, HTTP, dan WebSocket, meskipun dukungan transport dapat bervariasi menurut server **Melihat server MCP plugin**: ```bash theme={null} # Dalam Fuxi Code, lihat semua server MCP termasuk yang dari plugin /mcp ``` Server plugin muncul dalam daftar dengan indikator yang menunjukkan mereka berasal dari plugin. **Nama alat MCP plugin**: Alat dari server MCP bundel plugin mencakup nama plugin dan kunci server dalam nama yang dapat dipanggil. Bentuk lengkapnya adalah `mcp__plugin____`, di mana karakter apa pun di luar `A-Z`, `a-z`, `0-9`, `_`, dan `-` diganti dengan `_`. Untuk server `database-tools` yang dibundel dalam plugin bernama `my-plugin`, alat `query` dapat dipanggil sebagai: ``` mcp__plugin_my-plugin_database-tools__query ``` Gunakan nama lengkap ini saat mereferensikan alat dalam [aturan izin](/id/permissions), daftar `allowed-tools` skill, [bidang `tools` subagent](/id/sub-agents#available-tools), atau [pencocokan hook](/id/hooks#match-mcp-tools). Pencocokan hook yang ditulis terhadap kunci server telanjang, seperti `mcp__database-tools__.*`, tidak pernah aktif untuk server bundel plugin. Server itu sendiri terdaftar di bawah nama yang bersifat scoped `plugin::`, seperti `plugin:my-plugin:database-tools`. Gunakan nama tersebut di mana nama server yang dikonfigurasi diharapkan, seperti [bidang `server` hook `mcp_tool`](/id/hooks#mcp-tool-hook-fields). **Manfaat server MCP plugin**: * **Distribusi bundel**: Alat dan server dikemas bersama * **Pengaturan otomatis**: Tidak perlu konfigurasi MCP manual * **Konsistensi tim**: Semua orang mendapatkan alat yang sama ketika plugin diinstal Lihat [referensi komponen plugin](/id/plugins-reference#mcp-servers) untuk detail tentang penggabungan server MCP dengan plugin.

Cakupan instalasi MCP

Server MCP dapat dikonfigurasi pada tiga cakupan berbeda. Cakupan yang Anda pilih mengontrol proyek mana tempat server dimuat dan apakah konfigurasi dibagikan dengan tim Anda. Administrator juga dapat menerapkan server di tingkat enterprise melalui [konfigurasi terkelola](#managed-mcp-configuration). | Cakupan | Dimuat dalam | Dibagikan dengan tim | Disimpan dalam | | ------------------------ | --------------------- | ------------------------- | -------------------------- | | [Lokal](#local-scope) | Hanya proyek saat ini | Tidak | `~/.fuxi.json` | | [Proyek](#project-scope) | Hanya proyek saat ini | Ya, melalui kontrol versi | `.mcp.json` di root proyek | | [Pengguna](#user-scope) | Semua proyek Anda | Tidak | `~/.fuxi.json` |

Cakupan lokal

Cakupan lokal adalah default. Server dengan cakupan lokal hanya dimuat di proyek tempat Anda menambahkannya dan tetap pribadi untuk Anda. Fuxi Code menyimpannya dalam `~/.fuxi.json` di bawah jalur proyek tersebut, jadi server yang sama tidak akan muncul di proyek lain Anda. Gunakan cakupan lokal untuk server pengembangan pribadi, konfigurasi eksperimental, atau server dengan kredensial yang tidak ingin Anda masukkan ke dalam kontrol versi. Istilah "cakupan lokal" untuk server MCP berbeda dari pengaturan lokal umum. Server MCP dengan cakupan lokal disimpan dalam `~/.fuxi.json` (direktori home Anda), sementara pengaturan lokal umum menggunakan `.fuxi/settings.local.json` (di direktori proyek). Lihat [Pengaturan](/id/settings#settings-files) untuk detail tentang lokasi file pengaturan. ```bash theme={null} # Tambahkan server dengan cakupan lokal (default) fuxi mcp add --transport http stripe https://mcp.stripe.com # Tentukan cakupan lokal secara eksplisit fuxi mcp add --transport http stripe --scope local https://mcp.stripe.com ``` Perintah menulis server ke dalam entri untuk proyek saat ini di dalam `~/.fuxi.json`. Contoh di bawah menunjukkan hasilnya ketika Anda menjalankannya dari `/path/to/your/project`: ```json theme={null} { "projects": { "/path/to/your/project": { "mcpServers": { "stripe": { "type": "http", "url": "https://mcp.stripe.com" } } } } } ```

Cakupan proyek

Server dengan cakupan proyek memungkinkan kolaborasi tim dengan menyimpan konfigurasi dalam file `.mcp.json` di direktori root proyek Anda. File ini dirancang untuk diperiksa ke dalam kontrol versi, memastikan semua anggota tim memiliki akses ke alat dan layanan MCP yang sama. Ketika Anda menambahkan server dengan cakupan proyek, Fuxi Code secara otomatis membuat atau memperbarui file ini dengan struktur konfigurasi yang sesuai. ```bash theme={null} # Tambahkan server dengan cakupan proyek fuxi mcp add --transport http paypal --scope project https://mcp.paypal.com/mcp ``` File `.mcp.json` yang dihasilkan mengikuti format standar: ```json theme={null} { "mcpServers": { "shared-server": { "command": "/path/to/server", "args": [], "env": {} } } } ``` Untuk alasan keamanan, Fuxi Code meminta persetujuan sebelum menggunakan server dengan cakupan proyek dari file `.mcp.json`. Jika Anda perlu mengatur ulang pilihan persetujuan ini, gunakan perintah `fuxi mcp reset-project-choices`.

Cakupan pengguna

Server dengan cakupan pengguna disimpan dalam `~/.fuxi.json` dan menyediakan aksesibilitas lintas proyek, menjadikannya tersedia di semua proyek di mesin Anda sambil tetap pribadi untuk akun pengguna Anda. Cakupan ini bekerja dengan baik untuk server utilitas pribadi, alat pengembangan, atau layanan yang sering Anda gunakan di berbagai proyek. ```bash theme={null} # Tambahkan server pengguna fuxi mcp add --transport http hubspot --scope user https://mcp.hubspot.com/anthropic ```

Hierarki cakupan dan prioritas

Ketika server yang sama ditentukan di lebih dari satu tempat, Fuxi Code terhubung ke server tersebut sekali, menggunakan definisi dari sumber dengan prioritas tertinggi. Seluruh entri server dari sumber tersebut digunakan; bidang tidak digabungkan di seluruh cakupan. 1. Cakupan lokal 2. Cakupan proyek 3. Cakupan pengguna 4. [Server yang disediakan plugin](/id/plugins) 5. [Konektor fuxi.ai](#use-mcp-servers-from-fuxi-ai) Tiga cakupan mencocokkan duplikat berdasarkan nama. Plugin dan konektor mencocokkan berdasarkan endpoint, jadi yang menunjuk ke URL atau perintah yang sama dengan server di atas diperlakukan sebagai duplikat.

Ekspansi variabel lingkungan dalam `.mcp.json`

Fuxi Code mendukung ekspansi variabel lingkungan dalam file `.mcp.json`, memungkinkan tim untuk berbagi konfigurasi sambil mempertahankan fleksibilitas untuk jalur spesifik mesin dan nilai sensitif seperti kunci API. **Sintaks yang didukung:** * `${VAR}`: berkembang menjadi nilai variabel lingkungan `VAR` * `${VAR:-default}`: berkembang menjadi `VAR` jika diatur, jika tidak menggunakan `default` **Lokasi ekspansi:** Variabel lingkungan dapat berkembang dalam: * `command`: jalur executable server * `args`: argumen baris perintah * `env`: variabel lingkungan yang diteruskan ke server * `url`: untuk jenis server HTTP * `headers`: untuk autentikasi server HTTP **Contoh dengan ekspansi variabel:** ```json theme={null} { "mcpServers": { "api-server": { "type": "http", "url": "${API_BASE_URL:-https://api.example.com}/mcp", "headers": { "Authorization": "Bearer ${API_KEY}" } } } } ``` Jika variabel lingkungan yang diperlukan tidak diatur dan tidak memiliki nilai default, Fuxi Code akan gagal mengurai konfigurasi.

Contoh praktis

Contoh: Pantau kesalahan dengan Sentry

```bash theme={null} fuxi mcp add --transport http sentry https://mcp.sentry.dev/mcp ``` Autentikasi dengan akun Sentry Anda: ```text theme={null} /mcp ``` Kemudian debug masalah produksi: ```text theme={null} What are the most common errors in the last 24 hours? ``` ```text theme={null} Show me the stack trace for error ID abc123 ``` ```text theme={null} Which deployment introduced these new errors? ```

Contoh: Hubungkan ke GitHub untuk tinjauan kode

Server MCP jarak jauh GitHub diautentikasi dengan token akses pribadi GitHub yang diteruskan sebagai header. Untuk mendapatkan satu, buka [pengaturan token GitHub Anda](https://github.com/settings/personal-access-tokens), hasilkan token baru yang bersifat fine-grained dengan akses ke repositori yang ingin Fuxi kerjakan, kemudian tambahkan server: ```bash theme={null} fuxi mcp add --transport http github https://api.githubcopilot.com/mcp/ \ --header "Authorization: Bearer YOUR_GITHUB_PAT" ``` Kemudian bekerja dengan GitHub: ```text theme={null} Review PR #456 and suggest improvements ``` ```text theme={null} Create a new issue for the bug we just found ``` ```text theme={null} Show me all open PRs assigned to me ```

Contoh: Tanyakan database PostgreSQL Anda

```bash theme={null} fuxi mcp add --transport stdio db -- npx -y @bytebase/dbhub \ --dsn "postgresql://readonly:pass@prod.db.com:5432/analytics" ``` Kemudian tanyakan database Anda secara alami: ```text theme={null} What's our total revenue this month? ``` ```text theme={null} Show me the schema for the orders table ``` ```text theme={null} Find customers who haven't made a purchase in 90 days ```

Autentikasi dengan server MCP jarak jauh

Banyak server MCP berbasis cloud memerlukan autentikasi. Fuxi Code mendukung OAuth 2.0 untuk koneksi yang aman. Fuxi Code menandai server jarak jauh sebagai memerlukan autentikasi ketika server merespons dengan `401 Unauthorized` atau `403 Forbidden`. Salah satu kode status ini menandai server di `/mcp` sehingga Anda dapat menyelesaikan alur OAuth. Mulai dari v2.1.195, ketika penyegaran token gagal karena server menolak token penyegaran yang disimpan, Fuxi Code segera menampilkan pemberitahuan yang menunjuk ke `/mcp`. Menu server yang terhubung di sana menawarkan Re-authenticate, sehingga Anda dapat masuk lagi sebelum panggilan alat berikutnya gagal. Server kustom yang mengembalikan header `WWW-Authenticate` yang menunjuk ke server otorisasinya mendapatkan penemuan otomatis yang sama seperti server jarak jauh lainnya. Mulai dari v2.1.193, Fuxi Code juga menampilkan pemberitahuan startup ketika satu atau lebih server yang dikonfigurasi memerlukan autentikasi, sehingga Anda tidak perlu membuka `/mcp` untuk menemukan server mana yang memerlukan sign-in. Dalam mode non-interaktif tidak ada panel `/mcp`, jadi Fuxi Code tidak dapat menjalankan alur OAuth untuk Anda. Mulai dari v2.1.196, ketika server yang dikonfigurasi memerlukan autentikasi selama `fuxi -p` atau jalankan Agent SDK dengan [pencarian alat](#scale-with-mcp-tool-search) diaktifkan, yang merupakan default, Fuxi Code memberi tahu Fuxi bahwa alat server tidak tersedia sampai Anda mengotorisasinya. Fuxi kemudian dapat menyebutkan server yang memerlukan sign-in alih-alih merespons seolah-olah server tidak dikonfigurasi. Selesaikan sign-in dari sesi interaktif dengan `/mcp` atau `fuxi mcp login `. Jika Anda mengonfigurasi `headers.Authorization` untuk server dan server menolak header tersebut, Fuxi Code melaporkan koneksi sebagai gagal alih-alih kembali ke OAuth. Periksa bahwa token valid untuk endpoint MCP, atau hapus header untuk menggunakan alur OAuth. Sebagai contoh: ```bash theme={null} fuxi mcp add --transport http sentry https://mcp.sentry.dev/mcp ``` Dalam Fuxi Code, gunakan perintah: ```text theme={null} /mcp ``` Kemudian ikuti langkah-langkah di browser Anda untuk login. Tips: * Token autentikasi disimpan dengan aman dan disegarkan secara otomatis * Gunakan "Clear authentication" dalam menu `/mcp` untuk mencabut akses * Jika browser Anda tidak terbuka secara otomatis, salin URL yang disediakan dan buka secara manual * Jika pengalihan browser gagal dengan kesalahan koneksi setelah autentikasi, tempel URL callback lengkap dari bilah alamat browser Anda ke prompt URL yang muncul di Fuxi Code * Autentikasi OAuth bekerja dengan server HTTP

Autentikasi dari baris perintah

Dari v2.1.186, `fuxi mcp login ` menjalankan alur OAuth server yang dikonfigurasi langsung dari shell Anda, sehingga Anda tidak perlu membuka panel `/mcp` di dalam sesi. ```bash theme={null} fuxi mcp login sentry ``` Untuk menghapus kredensial yang disimpan nanti, jalankan `fuxi mcp logout `. Mulai dari v2.1.191, perintah mendeteksi ketika tidak ada browser lokal yang tersedia, seperti selama sesi SSH atau di Linux tanpa server tampilan, dan mencetak URL otorisasi alih-alih mencoba membuka browser. Buka URL di mesin lokal Anda, kemudian tempel URL pengalihan lengkap dari bilah alamat browser Anda kembali ke prompt. Perintah memerlukan terminal interaktif untuk langkah paste, jadi hubungkan dengan `ssh -t`. Teruskan `--no-browser` untuk memaksa prompt URL bahkan ketika browser lokal terdeteksi. ```bash theme={null} fuxi mcp login sentry --no-browser ```

Gunakan port callback OAuth tetap

Beberapa server MCP memerlukan URI pengalihan tertentu yang terdaftar sebelumnya. Secara default, Fuxi Code memilih port acak yang tersedia untuk callback OAuth. Gunakan `--callback-port` untuk memperbaiki port sehingga cocok dengan URI pengalihan yang telah terdaftar sebelumnya dalam bentuk `http://localhost:PORT/callback`. Anda dapat menggunakan `--callback-port` sendiri (dengan pendaftaran klien dinamis) atau bersama dengan `--client-id` (dengan kredensial yang telah dikonfigurasi sebelumnya). ```bash theme={null} # Port callback tetap dengan pendaftaran klien dinamis fuxi mcp add --transport http \ --callback-port 8080 \ my-server https://mcp.example.com/mcp ```

Gunakan kredensial OAuth yang telah dikonfigurasi sebelumnya

Beberapa server MCP tidak mendukung pengaturan OAuth otomatis melalui Dynamic Client Registration. Jika Anda melihat kesalahan seperti "Incompatible auth server: does not support dynamic client registration," server memerlukan kredensial yang telah dikonfigurasi sebelumnya. Fuxi Code juga mendukung server yang menggunakan Client ID Metadata Document (CIMD) alih-alih Dynamic Client Registration, dan menemukan ini secara otomatis. Jika penemuan otomatis gagal, daftarkan aplikasi OAuth melalui portal pengembang server terlebih dahulu, kemudian berikan kredensial saat menambahkan server. Buat aplikasi melalui portal pengembang server dan catat ID klien dan rahasia klien Anda. Banyak server juga memerlukan URI pengalihan. Jika demikian, pilih port dan daftarkan URI pengalihan dalam format `http://localhost:PORT/callback`. Gunakan port yang sama dengan `--callback-port` di langkah berikutnya. Pilih salah satu metode berikut. Port yang digunakan untuk `--callback-port` dapat berupa port apa pun yang tersedia. Itu hanya perlu cocok dengan URI pengalihan yang Anda daftarkan di langkah sebelumnya. Gunakan `--client-id` untuk meneruskan ID klien aplikasi Anda. Flag `--client-secret` meminta rahasia dengan input yang disembunyikan: ```bash theme={null} fuxi mcp add --transport http \ --client-id your-client-id --client-secret --callback-port 8080 \ my-server https://mcp.example.com/mcp ``` Sertakan objek `oauth` dalam konfigurasi JSON dan teruskan `--client-secret` sebagai flag terpisah: ```bash theme={null} fuxi mcp add-json my-server \ '{"type":"http","url":"https://mcp.example.com/mcp","oauth":{"clientId":"your-client-id","callbackPort":8080}}' \ --client-secret ``` Gunakan `--callback-port` tanpa ID klien untuk memperbaiki port sambil menggunakan pendaftaran klien dinamis: ```bash theme={null} fuxi mcp add-json my-server \ '{"type":"http","url":"https://mcp.example.com/mcp","oauth":{"callbackPort":8080}}' ``` Atur rahasia melalui variabel lingkungan untuk melewati prompt interaktif: ```bash theme={null} MCP_CLIENT_SECRET=your-secret fuxi mcp add --transport http \ --client-id your-client-id --client-secret --callback-port 8080 \ my-server https://mcp.example.com/mcp ``` Jalankan `/mcp` di Fuxi Code dan ikuti alur login browser. Tips: * Rahasia klien disimpan dengan aman di keychain sistem Anda (macOS) atau file kredensial, bukan di konfigurasi Anda * Jika server menggunakan klien OAuth publik tanpa rahasia, gunakan hanya `--client-id` tanpa `--client-secret` * `--callback-port` dapat digunakan dengan atau tanpa `--client-id` * Flag ini hanya berlaku untuk transport HTTP dan SSE. Mereka tidak berpengaruh pada server stdio * Gunakan `fuxi mcp get ` untuk memverifikasi bahwa kredensial OAuth dikonfigurasi untuk server

Ganti penemuan metadata OAuth

Arahkan Fuxi Code ke URL metadata otorisasi OAuth tertentu untuk melewati rantai penemuan default. Atur `authServerMetadataUrl` ketika endpoint standar server MCP mengembalikan kesalahan, atau ketika Anda ingin merutekan penemuan melalui proxy internal. Secara default, Fuxi Code pertama kali memeriksa Protected Resource Metadata RFC 9728 di `/.well-known/oauth-protected-resource`, kemudian kembali ke metadata server otorisasi RFC 8414 di `/.well-known/oauth-authorization-server`. Atur `authServerMetadataUrl` dalam objek `oauth` dari konfigurasi server Anda di `.mcp.json`: ```json theme={null} { "mcpServers": { "my-server": { "type": "http", "url": "https://mcp.example.com/mcp", "oauth": { "authServerMetadataUrl": "https://auth.example.com/.well-known/openid-configuration" } } } } ``` URL harus menggunakan `https://`. `scopes_supported` dari URL metadata mengganti cakupan yang diiklankan server upstream.

Batasi cakupan OAuth

Atur `oauth.scopes` untuk menyematkan cakupan yang diminta Fuxi Code selama alur otorisasi. Ini adalah cara yang didukung untuk membatasi server MCP ke subset yang disetujui tim keamanan ketika server otorisasi upstream mengiklankan lebih banyak cakupan daripada yang ingin Anda berikan. Nilainya adalah string tunggal yang dipisahkan spasi, cocok dengan format parameter `scope` dalam RFC 6749 §3.3. ```json theme={null} { "mcpServers": { "slack": { "type": "http", "url": "https://mcp.slack.com/mcp", "oauth": { "scopes": "channels:read chat:write search:read" } } } } ``` `oauth.scopes` mengambil prioritas atas `authServerMetadataUrl` dan cakupan yang ditemukan server di `/.well-known`. Biarkan tidak diatur untuk membiarkan server MCP menentukan set cakupan yang diminta. Mulai dari v2.1.196, ketika `oauth.scopes` tidak diatur, Fuxi Code meminta cakupan yang disediakan oleh header `WWW-Authenticate` server atau metadata sumber daya terlindungnya, dan tidak mengirim parameter `scope` ketika tidak ada yang menyediakannya. Itu tidak lagi meminta katalog `scopes_supported` lengkap dari metadata server otorisasi yang ditemukan secara otomatis. Meminta katalog itu membuat penyedia identitas yang mengiklankan cakupan khusus admin atau template menolak permintaan otorisasi dengan kesalahan `invalid_scope`. Metadata yang diambil dari `authServerMetadataUrl` yang dikonfigurasi masih menyediakan `scopes_supported` sebagai cakupan yang diminta. Jika server otorisasi mengiklankan `offline_access` dalam `scopes_supported`, Fuxi Code menambahkannya ke cakupan yang disematkan sehingga token akses dapat disegarkan tanpa login browser baru. Jika server kemudian mengembalikan 403 `insufficient_scope` untuk panggilan alat, Fuxi Code melakukan autentikasi ulang dengan cakupan yang disematkan yang sama. Perluas `oauth.scopes` ketika alat yang Anda butuhkan memerlukan cakupan di luar set yang disematkan.

Gunakan header dinamis untuk autentikasi khusus

Jika server MCP Anda menggunakan skema autentikasi selain OAuth, seperti Kerberos, token berumur pendek, atau SSO internal, gunakan `headersHelper` untuk menghasilkan header permintaan pada waktu koneksi. Fuxi Code menjalankan perintah dan menggabungkan outputnya ke dalam header koneksi. ```json theme={null} { "mcpServers": { "internal-api": { "type": "http", "url": "https://mcp.internal.example.com", "headersHelper": "/opt/bin/get-mcp-auth-headers.sh" } } } ``` Perintah juga dapat inline: ```json theme={null} { "mcpServers": { "internal-api": { "type": "http", "url": "https://mcp.internal.example.com", "headersHelper": "echo '{\"Authorization\": \"Bearer '\"$(get-token)\"'\"}'" } } } ``` **Persyaratan:** * Perintah harus menulis objek JSON dari pasangan kunci-nilai string ke stdout * Perintah berjalan dalam shell dengan waktu tunggu 10 detik * Header dinamis mengganti `headers` statis apa pun dengan nama yang sama Helper berjalan segar pada setiap koneksi, pada startup sesi dan pada reconnect. Tidak ada caching, jadi skrip Anda bertanggung jawab untuk penggunaan kembali token apa pun. Mulai dari v2.1.193, jika panggilan alat mengembalikan `401 Unauthorized` atau `403 Forbidden`, Fuxi Code secara otomatis menjalankan kembali helper, terhubung kembali dengan header segar, dan mencoba panggilan sekali lagi. Fuxi Code menandai server sebagai memerlukan autentikasi di `/mcp` hanya jika percobaan ulang itu juga gagal. Fuxi Code menetapkan variabel lingkungan ini saat menjalankan helper: | Variabel | Nilai | | :---------------------------- | :-------------------------------------------------------------------------------------------------------- | | `FUXI_CODE_MCP_SERVER_NAME` | nama server MCP | | `FUXI_CODE_MCP_SERVER_URL` | URL server MCP | | `FUXI_PLUGIN_ROOT` | direktori root plugin. Diatur hanya ketika [plugin](/id/plugins-reference#mcp-servers) menyediakan server | Gunakan ini untuk menulis satu skrip helper yang melayani beberapa server MCP. Untuk server yang disediakan plugin, helper juga berjalan dengan direktori kerjanya diatur ke root plugin, sehingga jalur `headersHelper` relatif diselesaikan di dalam direktori plugin daripada terhadap direktori kerja sesi. Memerlukan Fuxi Code v2.1.195 atau lebih baru. `headersHelper` mengeksekusi perintah shell arbitrer. Ketika ditentukan pada cakupan proyek atau lokal, itu hanya berjalan setelah Anda menerima dialog kepercayaan ruang kerja.

Tambahkan server MCP dari konfigurasi JSON

Jika Anda memiliki konfigurasi JSON untuk server MCP, Anda dapat menambahkannya secara langsung: ```bash theme={null} # Sintaks dasar fuxi mcp add-json '' # Contoh: Menambahkan server HTTP dengan konfigurasi JSON fuxi mcp add-json weather-api '{"type":"http","url":"https://api.weather.com/mcp","headers":{"Authorization":"Bearer token"}}' # Contoh: Menambahkan server stdio dengan konfigurasi JSON fuxi mcp add-json local-weather '{"type":"stdio","command":"/path/to/weather-cli","args":["--api-key","abc123"],"env":{"CACHE_DIR":"/tmp"}}' # Contoh: Menambahkan server HTTP dengan kredensial OAuth yang telah dikonfigurasi sebelumnya fuxi mcp add-json my-server '{"type":"http","url":"https://mcp.example.com/mcp","oauth":{"clientId":"your-client-id","callbackPort":8080}}' --client-secret ``` ```bash theme={null} fuxi mcp get weather-api ``` Tips: * Pastikan JSON diloloskan dengan benar di shell Anda * JSON harus sesuai dengan skema konfigurasi server MCP * Anda dapat menggunakan `--scope user` untuk menambahkan server ke konfigurasi pengguna Anda alih-alih yang spesifik proyek

Impor server MCP dari Fuxi Desktop

Jika Anda telah mengonfigurasi server MCP di Fuxi Desktop, Anda dapat mengimpornya: ```bash theme={null} # Sintaks dasar fuxi mcp add-from-fuxi-desktop ``` Setelah menjalankan perintah, Anda akan melihat dialog interaktif yang memungkinkan Anda memilih server mana yang ingin Anda impor. ```bash theme={null} fuxi mcp list ``` Nama server yang ditambahkan melalui perintah `fuxi mcp` hanya dapat berisi huruf, angka, tanda hubung, dan garis bawah. Fuxi Desktop tidak menerapkan pembatasan itu, jadi server Fuxi Desktop yang namanya berisi karakter lain, seperti spasi, tidak dapat diimpor. Impor melaporkan setiap nama yang ditolak dan tetap mengimpor server lain yang Anda pilih. Sebelum v2.1.205, nama tidak valid pertama menghentikan impor dan tidak ada server yang dipilih yang ditambahkan. Tips: * Fitur ini hanya bekerja di macOS dan Windows Subsystem for Linux (WSL) * Ini membaca file konfigurasi Fuxi Desktop dari lokasi standarnya di platform tersebut * Gunakan flag `--scope user` untuk menambahkan server ke konfigurasi pengguna Anda * Server yang diimpor mempertahankan nama yang sama seperti di Fuxi Desktop ketika nama hanya berisi huruf, angka, tanda hubung, dan garis bawah. Fuxi Code melaporkan server yang namanya berisi karakter lain dan melewatkannya * Jika server dengan nama yang sama sudah ada, mereka akan mendapatkan akhiran numerik (misalnya, `server_1`)

Gunakan server MCP dari fuxi.ai

Jika Anda telah masuk ke Fuxi Code dengan akun [fuxi.ai](https://fuxi.ai), server MCP yang telah Anda tambahkan di fuxi.ai secara otomatis tersedia di Fuxi Code: Tambahkan server di [fuxi.ai/customize/connectors](https://fuxi.ai/customize/connectors). Pada paket Tim dan Enterprise, hanya admin yang dapat menambahkan server. Selesaikan langkah autentikasi yang diperlukan di fuxi.ai. Di Fuxi Code, gunakan perintah: ```text theme={null} /mcp ``` Server dari fuxi.ai muncul dalam daftar dengan indikator yang menunjukkan mereka berasal dari fuxi.ai. Mulai dari v2.1.161, konektor yang belum pernah Anda masuki disembunyikan di balik baris `Show unused connectors` di akhir bagian fuxi.ai, sehingga daftar yang disediakan organisasi tidak mengisi panel. Pilih baris untuk memperluas mereka. Konektor yang Anda masuki sebelumnya tetap terlihat bahkan ketika saat ini memerlukan autentikasi ulang. Konektor dari fuxi.ai diambil hanya ketika [metode autentikasi](/id/authentication#authentication-precedence) aktif Anda adalah langganan fuxi.ai Anda. Mereka tidak dimuat ketika `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, `apiKeyHelper`, atau penyedia pihak ketiga seperti Amazon Bedrock atau Google Cloud's Agent Platform aktif, bahkan jika Anda sebelumnya menjalankan `/login`. Jika `/mcp` tidak mencantumkan konektor yang Anda tambahkan, jalankan `/status` untuk mengonfirmasi metode autentikasi mana yang aktif, hapus variabel lingkungan tersebut atau hapus pengaturan `apiKeyHelper`, kemudian jalankan `/login` untuk memilih akun fuxi.ai Anda. Server yang telah Anda tambahkan di Fuxi Code mengambil [prioritas](#scope-hierarchy-and-precedence) atas konektor fuxi.ai yang menunjuk ke URL yang sama. Ketika ini terjadi, `/mcp` mencantumkan konektor sebagai tersembunyi dan menunjukkan cara menghapus duplikat jika Anda lebih suka menggunakan konektor. Beberapa konektor yang dihosting Anthropic, seperti Microsoft 365, Gmail, dan Google Calendar, tidak mendukung OAuth lokal dari Fuxi Code karena penyedia identitas hulu hanya menerima URL pengalihan yang didaftarkan fuxi.ai. Mulai dari v2.1.162, mengautentikasi salah satu host ini di `/mcp` menampilkan pesan yang mengarahkan Anda untuk menghubungkannya di Settings → Connectors di fuxi.ai. Setelah terhubung di sana, konektor muncul di Fuxi Code secara otomatis.

Nonaktifkan konektor fuxi.ai

Untuk menonaktifkan server MCP fuxi.ai di Fuxi Code, atur [`disableFuxiAiConnectors`](/id/settings#available-settings) ke `true` dalam cakupan pengaturan apa pun: ```json theme={null} { "disableFuxiAiConnectors": true } ``` Pengaturan ini menggunakan semantik any-source-true: `true` dalam sumber pengaturan apa pun mengambil prioritas. File `.fuxi/settings.json` proyek yang diperiksa dapat mengeluarkan repositori dari konektor cloud, tetapi `false` tingkat proyek tidak dapat mengaktifkan kembali konektor yang telah dinonaktifkan oleh `true` tingkat pengguna atau kebijakan. Server yang dilewatkan secara eksplisit melalui `--mcp-config` tidak terpengaruh. Anda juga dapat mengatur variabel lingkungan `ENABLE_FUXIAI_MCP_SERVERS` ke `false`, yang memiliki efek yang sama untuk sesi shell saat ini: ```bash theme={null} ENABLE_FUXIAI_MCP_SERVERS=false fuxi ``` Untuk memblokir konektor fuxi.ai individual alih-alih semuanya, tambahkan mereka ke [`deniedMcpServers`](/id/managed-mcp) berdasarkan nama atau pola URL. Misalnya, entri `serverName` dari `"fuxi.ai Slack"` memblokir konektor Slack. Untuk mengalihkan konektor aktif atau nonaktif hanya untuk proyek saat ini, gunakan panel `/mcp`. Pengaturan sisi klien ini mengatur sesi Fuxi Code lokal. Dalam sesi [Fuxi Code di web](/id/fuxi-code-on-the-web), konektor fuxi.ai disediakan oleh host jarak jauh dan tiba sebagai entri `--mcp-config` eksplisit, jadi `disableFuxiAiConnectors` tidak berlaku di sana. URL konektor juga ditulis ulang melalui proxy sesi, jadi pola `serverUrl` `deniedMcpServers` yang menargetkan URL vendor tidak akan cocok. Kelola konektor mana yang dapat digunakan sesi cloud dari pengaturan organisasi fuxi.ai Anda.

Gunakan Fuxi Code sebagai server MCP

Anda dapat menggunakan Fuxi Code itu sendiri sebagai server MCP yang dapat terhubung oleh aplikasi lain: ```bash theme={null} # Mulai Fuxi sebagai server MCP stdio fuxi mcp serve ``` Anda dapat menggunakan ini di Fuxi Desktop dengan menambahkan konfigurasi ini ke fuxi\_desktop\_config.json: ```json theme={null} { "mcpServers": { "fuxi-code": { "type": "stdio", "command": "fuxi", "args": ["mcp", "serve"], "env": {} } } } ``` **Mengonfigurasi jalur executable**: Field `command` harus mereferensikan executable Fuxi Code. Jika perintah `fuxi` tidak ada di PATH sistem Anda, Anda perlu menentukan jalur lengkap ke executable. Untuk menemukan jalur lengkap: ```bash theme={null} which fuxi ``` Kemudian gunakan jalur lengkap dalam konfigurasi Anda: ```json theme={null} { "mcpServers": { "fuxi-code": { "type": "stdio", "command": "/full/path/to/fuxi", "args": ["mcp", "serve"], "env": {} } } } ``` Tanpa jalur executable yang benar, Anda akan mengalami kesalahan seperti `spawn fuxi ENOENT`. Tips: * Server menyediakan akses ke alat Fuxi seperti View, Edit, LS, dll. * Di Fuxi Desktop, coba minta Fuxi untuk membaca file di direktori, membuat edit, dan lainnya. * Server MCP ini hanya mengekspos alat Fuxi Code ke klien MCP Anda, jadi klien Anda sendiri bertanggung jawab untuk menerapkan konfirmasi pengguna untuk panggilan alat individual.

Batas output MCP dan peringatan

Ketika alat MCP menghasilkan output besar, Fuxi Code membantu mengelola penggunaan token untuk mencegah membanjiri konteks percakapan Anda: * **Ambang batas peringatan output**: Fuxi Code menampilkan peringatan ketika output alat MCP apa pun melebihi 10.000 token * **Batas yang dapat dikonfigurasi**: Anda dapat menyesuaikan token output MCP maksimum yang diizinkan menggunakan variabel lingkungan `MAX_MCP_OUTPUT_TOKENS` * **Batas default**: Maksimum default adalah 25.000 token * **Cakupan**: Variabel lingkungan berlaku untuk alat yang tidak mendeklarasikan batas mereka sendiri. Alat yang menetapkan [`anthropic/maxResultSizeChars`](#raise-the-limit-for-a-specific-tool) menggunakan nilai itu sebagai gantinya untuk konten teks, terlepas dari apa yang `MAX_MCP_OUTPUT_TOKENS` diatur. Alat yang mengembalikan data gambar masih tunduk pada `MAX_MCP_OUTPUT_TOKENS` Untuk meningkatkan batas untuk alat yang menghasilkan output besar: ```bash theme={null} export MAX_MCP_OUTPUT_TOKENS=50000 fuxi ``` Ini sangat berguna saat bekerja dengan server MCP yang: * Menanyakan dataset atau database besar * Menghasilkan laporan atau dokumentasi terperinci * Memproses file log atau informasi debugging yang luas

Naikkan batas untuk alat tertentu

Jika Anda membangun server MCP, Anda dapat mengizinkan alat individual untuk mengembalikan hasil yang lebih besar dari ambang batas default dengan menetapkan `_meta["anthropic/maxResultSizeChars"]` dalam entri `tools/list` alat. Fuxi Code menaikkan ambang batas alat tersebut ke nilai yang dianotasi, hingga batas keras 500.000 karakter. Ini berguna untuk alat yang mengembalikan output yang secara inheren besar tetapi diperlukan, seperti skema database atau pohon file lengkap. Tanpa anotasi, hasil yang melebihi ambang batas default disimpan ke disk dan diganti dengan referensi file dalam percakapan. ```json theme={null} { "name": "get_schema", "description": "Returns the full database schema", "_meta": { "anthropic/maxResultSizeChars": 200000 } } ``` Anotasi berlaku secara independen dari `MAX_MCP_OUTPUT_TOKENS` untuk konten teks, jadi pengguna tidak perlu menaikkan variabel lingkungan untuk alat yang mendeklarasikannya. Alat yang mengembalikan data gambar masih tunduk pada batas token. Jika Anda sering mengalami peringatan output dengan server MCP tertentu yang tidak Anda kontrol, pertimbangkan untuk meningkatkan batas `MAX_MCP_OUTPUT_TOKENS`. Anda juga dapat meminta penulis server untuk menambahkan anotasi `anthropic/maxResultSizeChars` atau untuk membuat halaman respons mereka. Anotasi tidak berpengaruh pada alat yang mengembalikan konten gambar; untuk itu, menaikkan `MAX_MCP_OUTPUT_TOKENS` adalah satu-satunya opsi.

Skema input alat dengan combinator tingkat root

Beberapa server MCP mendeklarasikan skema input alat sebagai union JSON Schema, dengan `anyOf`, `oneOf`, atau `allOf` di tingkat atas skema. Fuxi API tidak menerima kata kunci tersebut di root skema. Itu menerima combinator yang bersarang di dalam `properties`, yang Fuxi Code kirim tanpa perubahan. Mulai dari Fuxi Code v2.1.195, alat dengan combinator tingkat root tetap tersedia. Sebelum mengirim alat ke API, Fuxi Code meratakan skema menjadi satu objek dan menambahkan kalimat ke deskripsi alat yang memberi tahu Fuxi grup parameter mana yang termasuk bersama: * `allOf`: properti dari setiap cabang digabungkan, dan daftar `required` setiap cabang masih berlaku * `anyOf` dan `oneOf`: properti dari setiap cabang digabungkan, dan daftar `required` setiap cabang dijelaskan dalam deskripsi alat alih-alih ditegakkan oleh skema Server Anda menerima argumen apa pun yang dipilih Fuxi, jadi terus validasi kombinasi sisi server. Ketika Fuxi Code tidak dapat menghasilkan skema yang diterima API, atau pada deployment yang tidak menerima konfigurasi jarak jauh yang mengaktifkan penulisan ulang, seperti mesin offline, itu melewati alat itu, mencatat alasan dalam log server, dan meninggalkan alat server lainnya tersedia. Versi lebih awal dari v2.1.195 melewati setiap alat yang skema input-nya memiliki `anyOf`, `oneOf`, atau `allOf` tingkat root.

Memerlukan persetujuan untuk alat tertentu

Jika Anda membangun server MCP, Anda dapat menandai alat sebagai memerlukan persetujuan eksplisit pada setiap panggilan dengan menetapkan `_meta["anthropic/requiresUserInteraction"]` ke `true` dalam entri `tools/list` alat. Nilainya harus boolean JSON `true`; nilai lain diabaikan. Fuxi Code menampilkan prompt izin alat itu pada setiap panggilan, bahkan dalam mode izin `acceptEdits`, `auto`, dan `bypassPermissions` [permission modes](/id/permissions#permission-modes), dan tidak menawarkan opsi "jangan tanya lagi" untuk itu. [Aturan izin](/id/permissions#permission-rule-syntax) yang cocok dengan alat tidak melewati prompt baik. Dalam mode `dontAsk`, yang tidak pernah meminta, Fuxi Code menolak panggilan sebagai gantinya. Prompt harus mencapai seseorang. Dalam mode non-interaktif dengan [`--permission-prompt-tool`](/id/cli-reference#cli-flags), hasil `allow` dari alat prompt untuk alat yang ditandai dikonversi menjadi deny dengan pesan `MCP tool requires user interaction; not supported via --permission-prompt-tool`. Callback [`canUseTool`](/id/agent-sdk/permissions) Agent SDK menerima panggilan ini dan dapat menyetujuinya, karena host SDK diharapkan menunjukkannya kepada pengguna. Gunakan ini untuk alat yang prompt izinnya adalah poin itu sendiri, seperti langkah persetujuan atau pemberian akses di mana persetujuan otomatis berarti tidak ada manusia yang pernah setuju. Alat lain dari server yang sama menjaga perilaku izin normal mereka. Entri `tools/list` berikut menandai satu alat sebagai selalu memerlukan persetujuan. ```json theme={null} { "name": "grant_access", "description": "Requests access to a protected resource", "_meta": { "anthropic/requiresUserInteraction": true } } ``` Anotasi `anthropic/requiresUserInteraction` memerlukan Fuxi Code v2.1.199 atau lebih baru. Versi sebelumnya mengabaikannya dan menerapkan alur izin standar. Ketika sesi terhubung ke [Remote Control](/id/remote-control) atau host SDK, Fuxi Code menandai permintaan izin sebagai memerlukan interaksi pengguna, sehingga klien menampilkan prompt izin alat untuk Anda jawab alih-alih tindakan persetujuan satu ketukan.

Tanggapi permintaan elicitasi MCP

Server MCP dapat meminta input terstruktur dari Anda di tengah tugas menggunakan elicitasi. Ketika server memerlukan informasi yang tidak dapat diperolehnya sendiri, Fuxi Code menampilkan dialog interaktif dan meneruskan respons Anda kembali ke server. Tidak ada konfigurasi yang diperlukan di pihak Anda: dialog elicitasi muncul secara otomatis ketika server memintanya. Server dapat meminta input dengan dua cara: * **Mode formulir**: Fuxi Code menampilkan dialog dengan field formulir yang ditentukan oleh server (misalnya, prompt nama pengguna dan kata sandi). Isi field dan kirim. * **Mode URL**: Fuxi Code membuka URL browser untuk autentikasi atau persetujuan. Selesaikan alur di browser, kemudian konfirmasi di CLI. Untuk merespons otomatis permintaan elicitasi tanpa menampilkan dialog, gunakan [hook `Elicitation`](/id/hooks#elicitation). Jika Anda membangun server MCP yang menggunakan elicitasi, lihat [spesifikasi elicitasi MCP](https://modelcontextprotocol.io/docs/learn/client-concepts#elicitation) untuk detail protokol dan contoh skema.

Gunakan sumber daya MCP

Server MCP dapat mengekspos sumber daya yang dapat Anda referensikan menggunakan penyebutan @, mirip dengan cara Anda mereferensikan file.

Referensikan sumber daya MCP

Ketik `@` dalam prompt Anda untuk melihat sumber daya yang tersedia dari semua server MCP yang terhubung. Sumber daya muncul bersama file dalam menu pelengkapan otomatis. Gunakan format `@server:protocol://resource/path` untuk mereferensikan sumber daya: ```text theme={null} Can you analyze @github:issue://123 and suggest a fix? ``` ```text theme={null} Please review the API documentation at @docs:file://api/authentication ``` Anda dapat mereferensikan beberapa sumber daya dalam satu prompt: ```text theme={null} Compare @postgres:schema://users with @docs:file://database/user-model ``` Tips: * Sumber daya secara otomatis diambil dan disertakan sebagai lampiran saat direferensikan * Jalur sumber daya dapat dicari fuzzy dalam pelengkapan otomatis penyebutan @ * Fuxi Code secara otomatis menyediakan alat untuk membuat daftar dan membaca sumber daya MCP ketika server mendukungnya * Sumber daya dapat berisi jenis konten apa pun yang disediakan server MCP (teks, JSON, data terstruktur, dll.) Pencarian Alat menjaga penggunaan konteks MCP tetap rendah dengan menunda definisi alat sampai Fuxi membutuhkannya. Hanya nama alat dan instruksi server yang dimuat saat startup sesi, jadi menambahkan lebih banyak server MCP memiliki dampak minimal pada jendela konteks Anda. Fuxi Code tidak memberlakukan batas alat tetap per-server; batas praktisnya adalah anggaran jendela konteks Anda.

Cara kerjanya

Pencarian Alat diaktifkan secara default. Alat MCP ditangguhkan daripada dimuat ke konteks sebelumnya, dan Fuxi menggunakan alat pencarian untuk menemukan yang relevan saat tugas membutuhkannya. Hanya alat yang benar-benar digunakan Fuxi yang memasuki konteks. Dari perspektif Anda, alat MCP bekerja persis seperti sebelumnya. Jika Anda lebih suka pemuatan berbasis ambang batas, atur `ENABLE_TOOL_SEARCH=auto` untuk memuat skema sebelumnya ketika mereka cocok dalam 10% jendela konteks dan hanya menunda overflow. Lihat [Konfigurasi pencarian alat](#configure-tool-search) untuk semua opsi.

Untuk penulis server MCP

Jika Anda membangun server MCP, field instruksi server menjadi lebih berguna dengan Pencarian Alat yang diaktifkan. Instruksi server membantu Fuxi memahami kapan harus mencari alat Anda, mirip dengan cara [skills](/id/skills) bekerja. Tambahkan instruksi server yang jelas dan deskriptif yang menjelaskan: * Kategori tugas apa yang ditangani alat Anda * Kapan Fuxi harus mencari alat Anda * Kemampuan utama yang disediakan server Anda Fuxi Code memotong deskripsi alat dan instruksi server pada 2KB masing-masing. Jaga agar ringkas untuk menghindari pemotongan, dan letakkan detail penting di dekat awal. Pencarian alat diaktifkan secara default: alat MCP ditangguhkan dan ditemukan sesuai permintaan. Fuxi Code menonaktifkannya secara default di Platform Agent Google Cloud. Pencarian alat juga dinonaktifkan ketika `ANTHROPIC_BASE_URL` menunjuk ke host non-pihak pertama, karena sebagian besar proxy tidak meneruskan blok `tool_reference`. Atur `ENABLE_TOOL_SEARCH` secara eksplisit untuk mengganti fallback mana pun. Pencarian alat memerlukan model yang mendukung blok `tool_reference`. Model Haiku tidak mendukungnya. Di Platform Agent Google Cloud, pencarian alat didukung untuk Fuxi Sonnet 4.5 dan lebih baru serta Fuxi Opus 4.5 dan lebih baru. Kontrol perilaku pencarian alat dengan variabel lingkungan `ENABLE_TOOL_SEARCH`: | Nilai | Perilaku | | :------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | (tidak diatur) | Semua alat MCP ditangguhkan dan dimuat sesuai permintaan. Kembali ke pemuatan sebelumnya di Platform Agent Google Cloud atau ketika `ANTHROPIC_BASE_URL` adalah host non-pihak pertama | | `true` | Semua alat MCP ditangguhkan. Fuxi Code mengirim header beta bahkan di Platform Agent Google Cloud dan melalui proxy. Permintaan gagal pada model Platform Agent Google Cloud lebih awal dari Sonnet 4.5 atau Opus 4.5, atau pada proxy yang tidak mendukung blok `tool_reference` | | `auto` | Mode ambang batas: alat dimuat sebelumnya jika cocok dalam 10% jendela konteks, ditangguhkan sebaliknya | | `auto:N` | Mode ambang batas dengan persentase khusus, di mana `N` adalah 0-100. Misalnya, `auto:5` untuk 5% | | `false` | Semua alat MCP dimuat sebelumnya, tidak ada penundaan | ```bash theme={null} # Gunakan ambang batas khusus 5% ENABLE_TOOL_SEARCH=auto:5 fuxi # Nonaktifkan pencarian alat sepenuhnya ENABLE_TOOL_SEARCH=false fuxi ``` Atau atur nilai dalam [field `env` settings.json](/id/settings#available-settings) Anda. Anda juga dapat menonaktifkan alat `ToolSearch` secara khusus: ```json theme={null} { "permissions": { "deny": ["ToolSearch"] } } ```

Keluarkan server dari penundaan

Jika alat server harus selalu terlihat oleh Fuxi tanpa langkah pencarian, atur `alwaysLoad` ke `true` dalam konfigurasi server tersebut. Setiap alat dari server tersebut kemudian dimuat ke konteks saat startup sesi terlepas dari pengaturan `ENABLE_TOOL_SEARCH`. Gunakan ini untuk sejumlah kecil alat yang Fuxi butuhkan di setiap putaran, karena setiap alat sebelumnya mengonsumsi konteks yang sebaliknya akan tersedia untuk percakapan Anda. Entri `.mcp.json` berikut mengecualikan satu server HTTP sambil membiarkan server lain ditangguhkan: ```json theme={null} { "mcpServers": { "core-tools": { "type": "http", "url": "https://mcp.example.com/mcp", "alwaysLoad": true } } } ``` Field `alwaysLoad` tersedia di semua jenis server dan memerlukan Fuxi Code v2.1.121 atau lebih baru. Server MCP juga dapat menandai alat individual sebagai selalu-dimuat dengan menyertakan `"anthropic/alwaysLoad": true` dalam objek `_meta` alat, yang memiliki efek yang sama hanya untuk alat tersebut. Pengaturan `alwaysLoad: true` juga memblokir startup sampai server terhubung, dibatasi pada timeout koneksi standar 5 detik. Ini berlaku bahkan ketika MCP startup adalah [non-blocking secara default](/id/env-vars), karena alat harus ada saat prompt pertama dibangun. Server lain terus terhubung di latar belakang.

Gunakan prompt MCP sebagai perintah

Server MCP dapat mengekspos prompt yang menjadi tersedia sebagai perintah di Fuxi Code.

Jalankan prompt MCP

Ketik `/` untuk melihat semua perintah yang tersedia, termasuk yang dari server MCP. Prompt MCP muncul dengan format `/mcp__servername__promptname`. ```text theme={null} /mcp__github__list_prs ``` Banyak prompt menerima argumen. Teruskan mereka dipisahkan spasi setelah perintah: ```text theme={null} /mcp__github__pr_review 456 ``` ```text theme={null} /mcp__jira__create_issue "Bug in login flow" high ``` Tips: * Prompt MCP ditemukan secara dinamis dari server yang terhubung * Argumen diurai berdasarkan parameter yang ditentukan prompt * Hasil prompt disuntikkan langsung ke dalam percakapan * Nama server dan prompt dinormalisasi, dengan spasi dikonversi menjadi garis bawah

Konfigurasi MCP yang dikelola

Untuk organisasi yang memerlukan kontrol terpusat atas server MCP mana yang dapat dihubungkan pengguna, lihat [Konfigurasi MCP yang dikelola](/id/managed-mcp). Ini mencakup penerapan set server tetap dengan `managed-mcp.json`, pembatasan server dengan `allowedMcpServers` dan `deniedMcpServers`, dan apa yang dilihat pengguna ketika server diblokir.