Skip to main content

MCP Servers

The MCP Servers interface provides a centralized location to discover, connect to, and manage Model Context Protocol servers. Access it by clicking the MCP server icon in the top right corner of the PostQode chat.

Server Catalog​

The Server Catalog tab provides a curated collection of community-made MCP servers that you can install with a single click.

Browsing the Catalog​

The catalog includes powerful filtering and sorting options to help you find the right servers:

Filter by Category​

Choose from various categories to narrow your search:

  • All Categories: View all available servers
  • Browser Automation: Tools for web scraping, browser control, and automation
  • Cloud Platforms: Integration with AWS, Azure, GCP, and other cloud services
  • Communication: Email, messaging, and notification services
  • Databases: Database connections and query tools
  • Developer Tools: Code analysis, testing, and development utilities
  • Ecommerce & Retail: Shopify, WooCommerce, and other retail platforms
  • File Systems: File management and storage solutions
  • Version Control: Git, GitHub, GitLab, and other VCS integrations

Sort Options​

Organize servers by:

  • Most Installs: Popular servers used by the community
  • Newest: Recently added servers
  • GitHub Stars: Highly rated servers on GitHub
  • Name: Alphabetical order

Server Cards​

Each server in the catalog displays:

  • Server Logo: Visual identification
  • Server Name: The name of the MCP server
  • Author: GitHub username or organization
  • GitHub Stars: Community popularity indicator
  • Install Count: Number of installations
  • Description: What the server does and its capabilities
  • Tags: Categories and features (e.g., version-control, github, repository-management)
  • Install Button: One-click installation

Example Servers​

GitHub MCP Server​

GitHub

Author: github
⭐ 22,712 | 📦 25,447 installs

Provides comprehensive GitHub API integration for repository management, issues, pull requests, and code operations with authentication and enterprise support.

Tags: version-control github repository-management code-collaboration git source-control

Install

Shopify MCP Server​

Shopify

Author: pashpashpash
⭐ 33 | 📦 1,196 installs

Integrates with Shopify's GraphQL Admin API to manage store data, including products, customers, orders, collections, discounts, and webhooks.

Tags: ecommerce-retail shopify ecommerce store-management graphql retail

Install

Installing from the Catalog​

When you click the Install button on a server:

  1. PostQode redirects you to the chat interface
  2. PostQode automatically sets up the server configuration
  3. If the server requires an API key or credentials, PostQode will guide you through the setup process
  4. The server is added to your MCP settings automatically
  5. You'll receive confirmation when installation is complete
tip

Use a Claude Sonnet model for the best installation experience. It provides better error handling and configuration assistance.

Remote Servers​

The Remote Servers tab allows you to connect to existing MCP servers via URL endpoints. This is useful for:

  • Connecting to custom MCP servers hosted on your infrastructure
  • Accessing third-party MCP services
  • Connecting to development servers during testing

Adding a Remote Server​

To add a remote MCP server:

  1. Navigate to the Remote Servers tab
  2. Fill in the required information:
    • Server Name: A unique, descriptive name for the server (e.g., "My Custom API Server")
    • Server URL: The complete URL endpoint of the MCP server (e.g., https://example.com/mcp-sse)
  3. Click the Add Server button
  4. PostQode will attempt to connect and display the connection status
Security Notice

When connecting to a remote server, ensure you trust the source. MCP servers can execute code and access data in your environment. Always verify the server's authenticity and review its privacy policy before connecting.

Remote Server Configuration​

After adding a remote server, you can configure additional settings:

{
  "mcpServers": {
    "myRemoteServer": {
      "url": "https://example.com/mcp-sse",
      "headers": {
        "Authorization": "Bearer your-token"
      },
      "alwaysAllow": ["tool1", "tool2"],
      "disabled": false,
      "timeout": 60
    }
  }
}

Edit Configuration​

Click the Edit Configuration button to:

  • Modify the server URL
  • Add authentication headers
  • Configure auto-approval settings
  • Adjust timeout values
  • Enable or disable the server

Third-Party Marketplaces​

Several third-party marketplaces provide directories of remote MCP servers:

Composio MCP Integration​

Composio's MCP Marketplace provides access to cloud-hosted MCP servers for services like GitHub, Notion, Slack, and more. Each server includes:

  • Built-in authentication support (OAuth, API keys)
  • Configuration instructions
  • Integration examples

Smithery​

Smithery is an independent MCP server marketplace where you can discover and connect to various Model Context Protocol servers.

Third-Party Services

These marketplaces are listed for informational purposes only. PostQode does not endorse, verify, or take responsibility for servers listed on these platforms. These are cloud-hosted services that may process your data. Always review privacy policies and terms of use before connecting.

Installed​

The Installed tab shows all MCP servers currently configured in PostQode, whether installed from the catalog or added as remote servers.

When No Servers Are Installed​

If you haven't installed any MCP servers yet, you'll see:

No MCP servers installed

The Model Context Protocol enables communication with locally running MCP servers that provide additional tools and resources to extend PostQode's capabilities. You can use community-made servers or ask PostQode to create new tools specific to your workflow (e.g., "add a tool that gets the latest npm docs").

See a demo here

Managing Installed Servers​

Once you have servers installed, each server displays:

Server Status Indicators​

  • 🟢 Green dot: Connected and ready to use
  • 🟡 Yellow dot: Connecting or initializing
  • 🔴 Red dot: Disconnected or experiencing errors

Server Information​

  • Server Name: The name you assigned or the catalog name
  • Server Type: Local (STDIO) or Remote (SSE)
  • Available Tools: Number of tools provided by the server
  • Available Resources: Number of resources provided by the server

Server Controls​

Click on a server to expand its settings panel and access:

  1. Enable/Disable Toggle

    • Toggle the switch to enable or disable the server
    • Disabled servers remain in your configuration but are not active

  2. Tools & Resources

    • View all available tools from the server
    • Configure auto-approval settings for specific tools
    • View available resources

  3. Request Timeout

    • Set maximum wait time for server responses
    • Options: 30 seconds to 1 hour (default: 1 minute)
    • Adjust based on your server's typical response time

  4. Server Actions

    • Restart Server: Reconnect if the server becomes unresponsive
    • Delete Server: Remove the server from your configuration (no confirmation dialog)

Configuration Files​

At the bottom of the Installed tab, you'll find two important buttons:

Configure MCP Servers​

Opens the postqode_mcp_settings.json file where all server configurations are stored:

{
  "mcpServers": {
    "github": {
      "command": "node",
      "args": ["/path/to/github-mcp-server/dist/index.js"],
      "env": {
        "GITHUB_TOKEN": "your_token_here"
      },
      "alwaysAllow": ["search_repositories", "get_file_contents"],
      "disabled": false
    },
    "remote-api": {
      "url": "https://api.example.com/mcp-sse",
      "headers": {
        "Authorization": "Bearer token"
      },
      "disabled": false
    }
  }
}

Advanced MCP Settings​

When you click on Advanced MCP Settings in the MCP Servers ➔ Installed tab (located at the bottom of the page when installed servers are present), you will be navigated to MCP Feature Settings:

  1. Enable MCP Marketplace: Toggle access to the built-in MCP Marketplace to discover and install community and partner servers.
  2. MCP Display Mode: Configure how MCP servers, tools, and actions are displayed within the PostQode UI.
  3. Collapse MCP Responses: Automatically collapse large MCP tool response payloads in the chat to keep your conversation context clean and readable.
Additional Auto-Approve Settings

For additional settings, you can navigate to Auto-Approve settings from the task page:

  • Enable Use MCP servers: Enable this option to permit the usage of auto-approval settings for MCP server tool execution.

Using MCP Servers​

After installing and configuring MCP servers, PostQode automatically integrates their capabilities:

Automatic Tool Detection​

PostQode will:

  1. Detect when an MCP tool can help with your task
  2. Suggest using the appropriate tool
  3. Request approval (unless auto-approved)
  4. Execute the tool and incorporate results

Example Usage​

With GitHub MCP Server installed:

You: "Search for React repositories with more than 10k stars"
PostQode: I'll use the GitHub MCP server to search for repositories...
[Uses search_repositories tool]

With Shopify MCP Server installed:

You: "Get the top 10 products from my Shopify store"
PostQode: I'll fetch your products using the Shopify MCP server...
[Uses get_products tool]

Tool Approval​

When PostQode wants to use an MCP tool:

  1. A prompt appears showing:
    • Tool name
    • Parameters being used
    • Expected action
  2. Review the details
  3. Approve or deny the tool use
  4. Results are returned to PostQode
Auto-Approval

Configure frequently-used, safe tools for auto-approval to streamline your workflow. Access this in each server's settings panel.

Troubleshooting​

Common Issues​

Server Not Responding​

  • Check if the server process is running
  • Verify network connectivity for remote servers
  • Try restarting the server
  • Check the server logs for errors

Permission Errors​

  • Ensure API keys and credentials are correctly configured
  • Verify environment variables are set properly
  • Check file permissions for local servers

Tool Not Available​

  • Confirm the server is enabled
  • Verify the tool is not disabled in settings
  • Check that the server properly implements the tool
  • Restart the server to refresh available tools

Slow Performance​

  • Adjust the network timeout value
  • Check your internet connection for remote servers
  • Consider using local servers for better performance
  • Review server logs for performance issues

Getting Help​

If you continue to experience issues:

  1. Check the server's documentation on GitHub
  2. Review the MCP server logs
  3. Try removing and reinstalling the server
  4. Test the server directly via command line
  5. Report issues using the /reportbug command in PostQode

Best Practices​

Security​

  • Only install servers from trusted sources
  • Review server code before installation when possible
  • Use environment variables for sensitive credentials
  • Regularly update servers to get security patches
  • Be cautious with auto-approval settings

Performance​

  • Disable unused servers to reduce token usage
  • Use local servers when possible for better latency
  • Configure appropriate timeout values
  • Monitor token usage in your API provider dashboard

Organization​

  • Use descriptive names for remote servers
  • Group related servers using MCP Rules
  • Document custom server configurations
  • Keep your postqode_mcp_settings.json backed up

MCP Rules​

Use .postqoderules or custom instructions to define when to use specific servers:

{
  "mcpRules": {
    "webInteraction": {
      "servers": ["firecrawl-mcp-server", "fetch-mcp"],
      "triggers": ["web", "scrape", "browse", "website"],
      "description": "Tools for web browsing and scraping"
    },
    "versionControl": {
      "servers": ["github"],
      "triggers": ["github", "repository", "pull request", "issue"],
      "description": "GitHub repository management"
    }
  }
}

This helps PostQode automatically select the right tools based on your conversation context.

Is this documentation incorrect or incomplete? Report an issue on GitHub