Connect any MCP server.Or write your own.
Megha speaks the Model Context Protocol, so the systems you already run plug straight into the agent layer. A directory of verified connectors covers the common ones, and anything you write yourself works the same way.
Where an MCP server actually sits.
A local connector is a subprocess on your machine. A remote one is a service across the network. The difference decides who else can see what you send.
Local servers stay on the machine. Remote servers do not.
Both are useful. Knowing which one you are connecting is the part that matters.
- Runs as a subprocess on your machine, started and stopped with the session
- No account, no network hop, nothing to authenticate against
- Credentials it needs (a database DSN, a path) stay in your own config
- The obvious choice for databases, files, and internal CLIs
- Reaches a service over the network, so its operator sees what you send
- OAuth sign-in handled in-app for servers that require it
- Best for SaaS you already use and already trust with the same data
- Disconnect at any time from the same directory you added it in
Connections live in a file you can read.
Every connection you make is written to a plain configuration file: name, transport, where to reach it, and whether it is on. You can read it, keep it in version control, and copy it to another machine.
- One file, version-controllable, deployable across a fleet
- Local and remote servers described the same way
- Each server independently switched on or off
- The same file works on the Mac app, the desktop, and the full OS
{
"servers": [
{
"name": "github",
"transport": "http",
"command": "https://api.githubcopilot.com/mcp",
"auth": "oauth",
"enabled": true
},
{
"name": "postgres",
"transport": "stdio",
"command": "mcp-server-postgres",
"args": ["--dsn", "postgresql://localhost/analytics"],
"enabled": true
}
]
}What you are actually agreeing to.
An MCP server is third-party code reaching your data. Being precise about what a connection grants is more useful than reassurance.
Connecting a server is the approval
You add a server deliberately, either from the directory or by pointing at one you wrote, and for remote servers you sign in. From then on its tools run inside the conversation without a confirmation card on every call, which is what makes them usable at all.
That means the server is trusted, and you should treat it that way
A connected server can see the arguments the agent sends it, and its tool descriptions become part of what the model reads. Connect servers the way you add a dependency: from a source you have reason to trust.
Each connection is independent
Servers are enabled and disabled one at a time. Turning one off does not disturb any other connection, and nothing it was doing survives the toggle.
Nothing is locked to us
The protocol is open and the config is a plain file you can read, diff and copy between machines. A server written for MeghaOS is just an MCP server.
Every grant, on one screen, on demand.
The honest answer to “what can this thing reach?” is a list, and the system will compose it for you whenever you ask. Drawn here by the desktop's own renderer; the servers are invented.
What can it actually reach right now?
Three servers, and what each one opens
Every tool it holds
| Tool | Reaches | Needs you |
|---|---|---|
| read_file | This folder | no |
| write_file | This folder | no |
| search_issues | Tracker | no |
| post_comment | Tracker | yes |
| list_events | Calendar | no |
Ceilings
Reached either ceiling and the run stops, rather than quietly continuing.
What is in the directory.
Issues & docs
GitHub, Linear, Atlassian, Notion, Asana. Official connectors, OAuth sign-in.
Business systems
Stripe, Sentry, Canva and others, verified and ready to connect.
Databases & internal tools
Postgres, SQLite, or whatever your team exposes, as a local server.
Your own servers
Anything you write. The protocol is open and MeghaOS does not care who wrote it.
Connecting a server, start to finish.
Most of it is picking from a list. Writing your own takes a name and an endpoint.
- Step 1
Open the server directory
MeghaOS ships a directory of verified connectors for services people actually use: GitHub, Notion, Linear, Atlassian, Stripe, Sentry, Asana and others. Browse it from the app rather than hunting for endpoints.
- Step 2
Pick a connector, or point at your own
Choose one from the directory, or add a server you wrote by giving it a name and either a command to run locally or a URL to reach.
- Step 3
Sign in, if the server asks
Remote connectors that need an account use OAuth, handled in the app. Local servers usually need nothing, or a credential you put in their own configuration.
- Step 4
Use it in conversation
The connector is now part of what the agent can reach, and its tools run inside the chat as it works. Connecting it was the approval, so it does not stop to ask on every call.
- Step 5
Turn it off when you are done
Each server has its own switch. Disabling one leaves every other connection exactly as it was.
For the protocol itself (transports, primitives, how to write a server, and what a connection actually grants) see our complete guide to the Model Context Protocol.
What people ask about MCP here.
Which MCP servers work with MeghaOS?
Any server that implements the Model Context Protocol, over either stdio or streamable HTTP. MeghaOS ships a directory of verified connectors for common services, and there is no registration step for anything else; the protocol is open, and the client does not care who wrote the server.
What is the difference between a local and a remote MCP server?
A local server runs as a subprocess on your own machine, so nothing it does involves the network and it needs no account. A remote server is reached over HTTP, which means its operator sees the arguments the agent sends, which is appropriate for SaaS you already trust with the same data and a real consideration for anything else.
What am I trusting when I connect a server?
A connected server sees the arguments sent to its tools, and the descriptions it advertises become part of what the model reads when it decides what to do. Treat connecting one the way you treat adding a dependency: from a source you trust, and removed when you no longer need it.
Do I need an account or an API key to use MCP?
Not for MeghaOS itself. MCP support is part of the agent runtime and costs nothing. Individual servers may need their own credentials, such as a database connection string or an OAuth sign-in, and those belong to the server rather than to us.
How do I disconnect a server?
Turn it off in the same place you added it. Each connection is independent, so disabling one has no effect on the others.
Does the same configuration work across editions?
Yes. Connections are stored in a plain configuration file that is the same on the Mac app, the Linux desktop environment, and the full operating system: readable, diffable, and portable between machines.
Bring your own tools.
Connect the services you already run, from a directory of verified connectors, or point MeghaOS at a server you wrote yourself.