MCP

Model Context Protocol — extend agent capabilities with third-party tools.

MCP (Model Context Protocol) is an open standard for connecting AI agents with external tools and data sources. Aura Work supports MCP servers as a first-class extension mechanism alongside built-in skills and plugins. MCP allows you to add new capabilities without modifying the core application — just install a server and the agent can use its tools.

What is MCP?

MCP is a protocol that lets AI agents communicate with external services through a standardized interface. Think of it as a universal adapter for AI tools — instead of building custom integrations for each service, MCP provides a common language that both the agent and the service understand.

With MCP, you can connect the agent to:

Databases — query PostgreSQL, MySQL, SQLite, MongoDB
APIs — interact with GitHub, Slack, Discord, Jira, etc.
File systems — access cloud storage (S3, GCS, Azure Blob)
Development tools — linters, formatters, test runners
Custom services — your own internal tools and APIs

⚙️ How MCP Works in Aura Work

MCP servers are managed by the Plugins Helper sidecar (port 47824). When you add an MCP server:

1. The Plugins Helper starts the server process (for stdio) or connects to it (for SSE)
2. The server announces its capabilities (tools, resources, prompts)
3. These capabilities are registered with the agent engine
4. When the agent needs a tool, it can now call the MCP server's tools
5. Each tool call goes through the permission gate for approval

The agent automatically discovers which MCP tools are available and selects them when appropriate — you don't need to explicitly tell it to use an MCP tool.

🔌 Supported Transports

MCP supports two transport mechanisms:

Transport	How it Works	Best For
`stdio`	Server runs as a subprocess. Communication happens via stdin/stdout pipes.	Local tools, CLI wrappers, simple integrations
`SSE`	Server runs as an HTTP service. Communication happens via Server-Sent Events.	Remote services, containerized servers, multi-client setups

Most community MCP servers use stdio because it's simpler — no network configuration needed. Use SSE when the server needs to be shared across multiple clients or runs in a container.

📦 Installing MCP Servers

There are three ways to add MCP servers:

Method 1: Marketplace (Recommended)

Open the Plugins panel in the desktop app, search for an MCP server, and click Install. The marketplace handles versioning, updates, and dependency management.

Method 2: Manual Configuration

Add a server manually in Settings → Plugins → MCP Servers:

{
  "name": "my-database-server",
  "command": "node",
  "args": ["path/to/mcp-server.js"],
  "env": {
    "DATABASE_URL": "postgresql://localhost/mydb"
  }
}

Method 3: Project-Level Config

Add MCP servers to your project's aura.jsonc file:

{
  "mcp": {
    "test-project-server": {
      "type": "local",
      "command": ["node", "/path/to/test-mcp-server.js"],
      "enabled": true,
      "environment": {
        "TEST_ENV_VAR": "Hello from project-level config"
      }
    }
  }
}

Project-level servers are only available when working in that project — perfect for project-specific tools.

🔐 Security & Permissions

MCP tool calls are subject to the same permission system as built-in tools:

Per-tool approval — each MCP tool can be individually approved or denied
Sandboxed execution — MCP servers run in isolated processes
Permission declarations — servers must declare what they need access to
Audit logging — all MCP calls are logged with tool name, arguments, and result

In ask-first mode, you'll be prompted before each MCP tool call. You can set "always allow" for trusted servers in Settings → Permissions.

🛒 Marketplace

The marketplace (registry/marketplace.json) includes MCP servers alongside skills and plugins. Each entry includes:

Server manifest — command, args, env vars, transport type
Tool descriptions — what each tool does and its parameters
Localized descriptions — available in 20 languages
Version info — for updates and compatibility checks
Risk assessment — based on required permissions

Browse the marketplace in the Plugins panel or check registry/mcp/ for available servers.

🛠️ Developing MCP Servers

You can create your own MCP servers using the official MCP SDK:

// my-mcp-server.js
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({
  name: "my-custom-server",
  version: "1.0.0"
}, {
  capabilities: { tools: {} }
});

// Define a tool
server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "my_tool",
    description: "Does something useful",
    inputSchema: {
      type: "object",
      properties: {
        query: { type: "string", description: "Input query" }
      },
      required: ["query"]
    }
  }]
}));

// Handle tool calls
server.setRequestHandler("tools/call", async (request) => {
  const { name, arguments: args } = request.params;
  if (name === "my_tool") {
    return { content: [{ type: "text", text: "Result: " + args.query }] };
  }
});

// Start the server
const transport = new StdioServerTransport();
await server.connect(transport);

See examples/mcp-server/ for a complete working example.

💡 Common MCP Servers

Popular community MCP servers include:

Server	Purpose	Transport
`filesystem`	Read/write files, search, list directories	stdio
`github`	Manage repos, issues, PRs via GitHub API	stdio
`postgres`	Query PostgreSQL databases	stdio
`slack`	Send messages, read channels	stdio
`puppeteer`	Browser automation with Chrome	stdio
`brave-search`	Web search via Brave API	stdio

Find more at github.com/modelcontextprotocol/servers