Setting Up MCP Servers

What is MCP?

The Model Context Protocol (MCP) lets you connect external tools and services to your AI agents. Think of it as a plugin system that gives agents superpowers:

Query databases
Search documentation
Access APIs
Read cloud resources
Execute custom tools

1Code includes full MCP server lifecycle management with no config files required.

MCP Architecture

How it works:

You configure MCP servers in 1Code settings
Servers expose “tools” the agent can call
Agent decides when to use which tools
Tools execute and return results
Agent uses results to accomplish tasks

Finding MCP Servers

Built-in Plugin Marketplace

1Code includes a curated marketplace of popular MCP servers:

Open MCP settings

Go to Settings > MCP Servers tab

Browse plugins

Click Add Server > Browse MarketplacePopular plugins:

GitHub: Query issues, PRs, code search
PostgreSQL: Execute SQL queries
Filesystem: Read/write files with permission controls
Brave Search: Web search for documentation
Puppeteer: Browser automation

One-click install

Click Install on any plugin:

Configuration form appears
Enter required settings (API keys, URLs)
Server is added automatically
Agent can use it immediately

Community Servers

Explore community-created servers:

Awesome MCP Servers
MCP Server Registry
NPM packages tagged mcp-server
GitHub repos with mcp-server topic

Adding MCP Servers

Stdio Servers (Local Processes)

Most MCP servers run as local processes communicating via stdio:

Open settings

Settings > MCP Servers > Add Server

Choose agent

Select which agent can use this server:

Claude Code: For Claude-specific tools
Codex: For Codex-specific tools
Both: Available to all agents

Configure connection

Enter the command to start the server:Example: NPM package

{
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-postgres"],
  "env": {
    "POSTGRES_URL": "postgresql://user:pass@localhost/db"
  }
}

Example: Python script

{
  "command": "python",
  "args": ["/path/to/server.py"],
  "env": {
    "API_KEY": "your-api-key"
  }
}

Set scope

Choose when the server is available:

Global: Always available
Project-specific: Only for specific repositories

Test connection

Click Test to verify:

Server starts successfully
Tools are discovered
No authentication errors

HTTP/SSE Servers (Remote)

Some servers run as HTTP services:

Add remote server

Settings > MCP Servers > Add Server > HTTP/SSE

Enter URL

{
  "url": "https://your-mcp-server.example.com/sse",
  "headers": {
    "Authorization": "Bearer YOUR_TOKEN"
  }
}

Configure authentication

Add required headers, API keys, or OAuth tokens.

Test connection

Verify the server is reachable and tools are listed.

Configuring Common Servers

GitHub MCP Server

Query repositories, issues, and pull requests:

{
  "name": "github",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-github"],
  "env": {
    "GITHUB_TOKEN": "ghp_your_token_here"
  }
}

Get a token:

Go to GitHub Settings > Developer settings > Personal access tokens
Generate new token (classic)
Grant scopes: repo, read:org, read:user
Copy token to 1Code settings

Available tools:

search_repositories
search_code
search_issues
get_file_contents
create_issue
create_pull_request

PostgreSQL MCP Server

Execute SQL queries from chat:

{
  "name": "postgres",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-postgres"],
  "env": {
    "POSTGRES_URL": "postgresql://username:password@localhost:5432/database"
  }
}

Available tools:

query: Execute SELECT queries
execute: Run INSERT/UPDATE/DELETE
describe_table: Get table schema
list_tables: List all tables

Filesystem MCP Server

Safe file system access with permissions:

{
  "name": "filesystem",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-filesystem", "/allowed/path"],
  "env": {}
}

Available tools:

read_file: Read file contents
write_file: Write to files
list_directory: List directory contents
search_files: Find files by pattern

Filesystem server is restricted to the paths you specify. Only grant access to safe directories.

Brave Search MCP Server

Web search for finding documentation:

{
  "name": "brave-search",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-brave-search"],
  "env": {
    "BRAVE_API_KEY": "your-brave-api-key"
  }
}

Get API key:

Visit brave.com/search/api
Sign up for free tier (2000 queries/month)
Copy API key to 1Code

Available tools:

brave_web_search: General web search
brave_local_search: Location-based search

Managing MCP Servers

Viewing Connected Servers

The MCP settings panel shows all configured servers:

Status indicator: Green (connected), Red (failed), Yellow (needs auth)
Tool count: How many tools the server exposes
Last used: When the agent last called this server
Scope: Global or project-specific

Enabling/Disabling Servers

Toggle servers on/off without deleting:

Find the server in settings
Click the toggle switch
Server starts/stops immediately
Disabled servers don’t appear to agents

Use cases:

Temporarily disable expensive API servers
Turn off servers for specific projects
Debug issues by eliminating servers

Editing Server Configuration

Click the server name in settings
Modify connection details, env vars, or scope
Click Save
Server reconnects with new configuration

Deleting Servers

Click the three-dot menu on the server card
Select Delete
Confirm deletion
Server is removed immediately

Using MCP Servers in Chat

Automatic Tool Usage

Agents automatically use MCP tools when relevant: Example:

You: "Search our GitHub issues for bugs related to authentication"

Agent: I'll search for authentication bugs...
[Calls github.search_issues tool]
Found 12 issues. Here are the most relevant:
1. Issue #234: Login fails with OAuth
2. Issue #189: JWT token expiration...

No special syntax needed - the agent decides when tools are helpful.

Explicit Tool Mentions

Mention MCP servers explicitly with @:

You: @postgres show me all users created in the last 7 days

Agent: I'll query the database...
[Calls postgres.query tool]
Here are the 45 users created recently:
...

Tool Call Display

MCP tool calls appear as expandable cards:

Tool name: Which tool was called
Input: Arguments passed to the tool
Output: Formatted results
Timing: How long the call took

Example display:

┌─ github.search_code
│ Input: { query: "authentication bug", repo: "org/repo" }
│ Output: Found 23 results
│ Duration: 1.2s
└─

MCP Server Development

Create your own MCP servers to expose custom tools:

Quick Start

server.ts

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: "greet",
      description: "Greet a user by name",
      inputSchema: {
        type: "object",
        properties: {
          name: { type: "string" },
        },
        required: ["name"],
      },
    },
  ],
}));

// Handle tool calls
server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "greet") {
    const name = request.params.arguments?.name;
    return {
      content: [
        {
          type: "text",
          text: `Hello, ${name}! Welcome to MCP.`,
        },
      ],
    };
  }
  throw new Error(`Unknown tool: ${request.params.name}`);
});

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

Adding to 1Code

Once your server is ready:

Package as NPM module or standalone script
Add to 1Code via Settings > MCP Servers
Test with your agent
Share with the community!

Resources:

Security and Permissions

Best Practices

Least Privilege

Grant MCP servers only the permissions they need. Use read-only tokens when possible.

Scope Appropriately

Use project-specific scoping to limit server access to relevant repositories.

Audit Tools

Review what tools a server exposes before enabling it for agents.

Rotate Credentials

Regularly rotate API keys and tokens used by MCP servers.

Authentication Flows

Some MCP servers need OAuth authentication:

Add server with OAuth config
Click Authenticate in settings
Browser opens to provider’s auth page
Grant required permissions
Redirected back to 1Code
Server connects automatically

Supported OAuth providers:

GitHub
Google
Microsoft
Slack
Linear

Troubleshooting

Server shows 'failed' status

Check:

Command is correct and executable is in PATH
Environment variables are set properly
Required API keys are valid
Network access for HTTP servers

Debug:

Click server > View Logs to see error messages
Test command manually in terminal
Verify dependencies are installed (npx for NPM servers)

Tools not appearing in agent

Cause: Server might be disabled or scoped incorrectly.Solution:

Verify server is enabled (toggle is on)
Check scope matches your current project
Restart the chat to refresh tool list
Try mentioning the server explicitly with @servername

Authentication errors

Cause: Expired tokens or incorrect credentials.Solution:

Click Logout then Authenticate again
Regenerate API keys in the service’s settings
Update environment variables in server config
Check token has required scopes/permissions

Tool calls timing out

Cause: Server is slow or external API is down.Solution:

Check server logs for performance issues
Verify external APIs are reachable
Increase timeout in server config if needed
Consider caching for frequently called tools

Server won't start (Windows)

Cause: Windows path or shell issues.Solution:

Use full paths: C:\\Program Files\\nodejs\\npx.cmd
Set shell explicitly in config: "shell": "cmd.exe"
Check Windows Defender isn’t blocking execution
Run 1Code as administrator if needed

Next Steps

Custom Models

Configure custom AI models that work with your MCP servers.

Automations

Trigger agents with MCP tools automatically from external events.

Skills

Create custom skills that bundle MCP servers with prompts.

MCP Docs

Learn more about MCP protocol and server development.

Get Started

Core Features

Guides

Advanced

Documentation Index

​What is MCP?

​MCP Architecture

​Finding MCP Servers

​Built-in Plugin Marketplace

​Community Servers

​Adding MCP Servers

​Stdio Servers (Local Processes)

​HTTP/SSE Servers (Remote)

​Configuring Common Servers

​GitHub MCP Server

​PostgreSQL MCP Server

​Filesystem MCP Server

​Brave Search MCP Server

​Managing MCP Servers

​Viewing Connected Servers

​Enabling/Disabling Servers

​Editing Server Configuration

​Deleting Servers

​Using MCP Servers in Chat

​Automatic Tool Usage

​Explicit Tool Mentions

​Tool Call Display

​MCP Server Development

​Quick Start

​Adding to 1Code

​Security and Permissions

​Best Practices

Least Privilege

Scope Appropriately

Audit Tools

Rotate Credentials

​Authentication Flows

​Troubleshooting

​Next Steps

Custom Models

Automations

Skills

MCP Docs

Build docs developers (and LLMs) love

What is MCP?

MCP Architecture

Finding MCP Servers

Built-in Plugin Marketplace

Community Servers

Adding MCP Servers

Stdio Servers (Local Processes)

HTTP/SSE Servers (Remote)

Configuring Common Servers

GitHub MCP Server

PostgreSQL MCP Server

Filesystem MCP Server

Brave Search MCP Server

Managing MCP Servers

Viewing Connected Servers

Enabling/Disabling Servers

Editing Server Configuration

Deleting Servers

Using MCP Servers in Chat

Automatic Tool Usage

Explicit Tool Mentions

Tool Call Display

MCP Server Development

Quick Start

Adding to 1Code

Security and Permissions

Best Practices

Authentication Flows

Troubleshooting

Next Steps