Full Guide to Integrating External APIs with Qoder: Configurations, Service Comparison, and Hands‑On Examples

1. Qoder Supported External API Integration Methods

Qoder offers four primary ways to connect external APIs:

MCP (Model Context Protocol) : a standardized AI tool interface, described as the "USB of the AI world".

Plugin System : install domain‑specific plugins from the Marketplace for quick onboarding.

Custom Tools : develop bespoke integrations using the Qoder CLI SDK for highly customized needs.

Skills System : package workflow knowledge modules to support team collaboration.

2. Detailed MCP Configuration Steps

Configuration Entry

Open settings with Ctrl + Shift + ,, navigate to MCP , and click + Add .

Basic Configuration Format

{
  "mcpServers": {
    "ServiceName": {
      "command": "StartCommand",
      "args": ["Param1", "Param2"],
      "env": {"ENV_VAR_NAME": "Value"}
    }
  }
}

3. Comparison of Three Transport Protocols

STDIO : configure with command + args; suited for local servers; offers low latency and easy debugging.

Streamable HTTP : configure with url + headers; suited for remote services; supports multiple connections.

SSE (legacy) : also uses url + headers; suited for remote services; provides backward compatibility.

4. Common Configuration Examples

Example 1 – Local Python MCP Server

{
  "mcpServers": {
    "weather-server": {
      "command": "uv",
      "args": ["--directory", "D:/projects/weather-mcp", "run", "server.py"]
    }
  }
}

Example 2 – Node.js GitHub MCP

{
  "mcpServers": {
    "github-tools": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {"GITHUB_PERSONAL_ACCESS_TOKEN": "{API_KEY}"}
    }
  }
}

Example 4 – Database Tool with Environment Variables

{
  "mcpServers": {
    "database-tools": {
      "command": "python",
      "args": ["D:/projects/db-mcp/server.py"],
      "env": {
        "DB_HOST": "localhost",
        "DB_PORT": "5432",
        "DB_USER": "admin",
        "DB_PASSWORD": "{OPENAI_API_KEY}"
      }
    }
  }
}

5. Hands‑On Case: Integrating a Custom Weather REST API

Step 1 – Environment Preparation

# Create project
mkdir weather-mcp-server
cd weather-mcp-server
# Initialize Python project
uv init
uv venv
.venv\Scripts\activate  # Windows
# Install dependencies
uv add "mcp[cli]" httpx

Step 2 – Write MCP Server (Python)

from typing import Any
import httpx
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("weather-api")
API_BASE = "https://api.weather-example.com/v1"
API_KEY = "your-api-key"  # should be read from env

async def make_api_request(endpoint: str, params: dict = None) -> dict | None:
    """Send API request"""
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Accept": "application/json"
    }
    url = f"{API_BASE}/{endpoint}"
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(url, headers=headers, params=params, timeout=30.0)
            response.raise_for_status()
            return response.json()
        except Exception as e:
            print(f"API request failed: {e}", file=sys.stderr)
            return None

@mcp.tool()
async def get_forecast(city: str, days: int = 3) -> str:
    """Get city weather forecast (1‑7 days)"""
    data = await make_api_request("forecast", {"city": city, "days": min(days, 7)})
    if not data or "forecasts" not in data:
        return f"Unable to fetch forecast for {city}"
    result = [f"📍 {city} Weather Forecast
"]
    for forecast in data["forecasts"]:
        result.append(
            f"📅 {forecast['date']}
"
            f"🌡️ Temp: {forecast['temp_min']}°C ~ {forecast['temp_max']}°C
"
            f"🌤️ Condition: {forecast['condition']}
"
        )
    return "
---
".join(result)

@mcp.tool()
async def get_weather_warnings(city: str) -> str:
    """Get city weather warnings"""
    data = await make_api_request("warnings", {"city": city})
    if not data or "warnings" not in data or not data["warnings"]:
        return f"✅ {city} currently has no weather warnings"
    result = [f"⚠️ {city} Weather Warnings
"]
    for warning in data["warnings"]:
        result.append(
            f"🔴 Level: {warning['level']}
"
            f"📝 Type: {warning['type']}
"
            f"📄 Description: {warning['description']}
"
        )
    return "
---
".join(result)

def main():
    mcp.run(transport="stdio")

if __name__ == "__main__":
    main()

Step 3 – Configure Qoder (~/.mcp.json)

{
  "mcpServers": {
    "weather-api": {
      "command": "uv",
      "args": ["--directory", "D:/projects/weather-mcp-server", "run", "server.py"],
      "env": {"WEATHER_API_KEY": "{API_KEY}"}
    }
  }
}

Best Practices and Common Pitfalls

Do not hard‑code sensitive information; use environment variables.

Avoid printing large data blobs that may overflow context.

Prefer logging over print for diagnostics.

Use absolute paths for reliable file resolution.

Validate JSON syntax with python -m json.tool ~/.mcp.json.

Check command availability ( where uv, where node) and dependency installation ( uv sync, npm install).

For STDIO communication, redirect debug output to stderr instead of stdout.

Ensure tools are decorated with @mcp.tool() and have proper async signatures.

When API authentication fails (401/403), verify the environment variable and test the token with curl -H "Authorization: Bearer {API_KEY}".

6. Official Resources

Qoder MCP Documentation: https://docs.qoder.com/user-guide/chat/model-context-protocol

Qoder CLI SDK: https://docs.qoder.com/cli/sdk/mcp

MCP Official Site: https://modelcontextprotocol.io

MCP Servers Repository: https://github.com/modelcontextprotocol/servers

FastMCP Docs: https://gofastmcp.com

MCP Inspector: https://github.com/modelcontextprotocol/inspector