Manage MCP Servers

What is it?

MCP (Model Context Protocol) is an open standard that lets AI assistants connect to external tools, data sources, and services. Yukkai can talk to MCP servers to fetch information, run commands, or interact with third-party APIs — all without you writing custom integrations.

The Manage MCP Servers tool lets you add, configure, connect, and remove MCP servers from within Yukkai. Think of it as a control panel for plugging new capabilities into your assistant.

How it works

Each MCP server is a small bridge between Yukkai and an external service. When you add a server, Yukkai opens a connection to it — either by launching a local process (stdio transport) or by reaching a network endpoint (SSE or streamable HTTP transport). Once connected, the server can expose new tools or data to Yukkai automatically.

You manage servers through six actions:

Action	What it does
list	Shows all configured servers and their connection status
add	Registers a new MCP server
remove	Deletes a server from your configuration
connect	Opens a connection to an existing server
disconnect	Closes a connection without removing the server
toggle	Enables or disables a server
test	Verifies that a server responds correctly

How to use it

Adding a server

To add an MCP server you need three things:

1. A name — a short label to identify the server
2. A transport — how Yukkai will talk to it (stdio, sse, or streamable_http)
3. Transport-specific details — a command for stdio, or a URL for SSE/HTTP

You can also pass optional environment variables (as JSON) and choose whether the server starts enabled.

Listing servers

Run list any time to see which servers are configured, which are connected, and which are disabled. This is your go-to diagnostic step when something isn't working.

Testing a connection

After adding a server, use test to confirm it responds. This is especially useful after updates or network changes.

Enabling and disabling

Toggle lets you turn a server off without deleting it. Yukkai will skip any disabled server until you re-enable it.

Removing a server

Remove permanently deletes the server from your configuration. Yukkai will no longer attempt to connect to it.

Examples

Add a local stdio server

A stdio server runs as a local process. You provide the command and its arguments:

Action:  add
Name:    filesystem
Transport: stdio
Command: npx
Arguments: -y @modelcontextprotocol/server-filesystem /Users/yohann/Documents

This launches the official filesystem server, giving Yukkai access to files in the specified directory.

Add a network server (SSE)

For a server reachable over the network, use the SSE transport:

Action:  add
Name:    brave-search
Transport: sse
URL:     http://localhost:3001/sse

Add a server with environment variables

You can pass environment variables as a JSON object. To reference secrets stored in Yukkai's Vault, use the {{VAULT:service}} placeholder:

Action:  add
Name:    github
Transport: stdio
Command: npx
Arguments: -y @modelcontextprotocol/server-github
Env:     { "GITHUB_TOKEN": "{{VAULT:github}}" }

Yukkai resolves the placeholder at runtime, so your API keys never appear in plain text.

Add an HTTP streaming server

Some modern servers use the streamable HTTP transport:

Action:  add
Name:    weather-api
Transport: streamable_http
URL:     https://mcp.weather.example.com/stream

List all servers

Action: list

You'll get a table showing each server's name, transport, connection status, and whether it's enabled.

Test a server

Action: test
Name:   filesystem

If the server is healthy you'll get a success response; otherwise you'll see the error details.

Disable a server temporarily

Action: toggle
Name:   brave-search

Remove a server

Action: remove
Name:   github

Tips & best practices

• Start with list — before adding anything, check what's already configured. You might already have the server you need.
• Use the Vault for secrets — never paste API keys directly. Store them in Yukkai's Vault and reference them with {{VAULT:service}} in the environment variables.
• Test after every change — use test right after adding or updating a server so you catch configuration errors early.
• Disable instead of remove — if you're troubleshooting or only need a server occasionally, toggle it off rather than deleting it entirely.
• Keep names simple — use lowercase, hyphenated names like filesystem or github-tools. They'll be easier to manage and reference.
• One transport per server — each server uses exactly one transport type. If a service offers both stdio and HTTP, pick whichever fits your setup.
• Stdio servers need the command on your machine — make sure the required runtime (Node.js, Python, etc.) is installed before adding a stdio server.
• Network servers need a reachable URL — if Yukkai can't reach the endpoint, the connection will fail. Verify the URL and any firewall settings first.