Building MCP Servers

The App Store of AI Tools:

Pre-built MCP servers are ready-to-use integrations that connect your AI client (Claude Desktop, Cursor, etc.) to real-world tools and services. You do not need to write code - just configure them and your AI can suddenly access files, manage GitHub repos, query databases, and browse the web.

Think of it like installing apps on your phone. Your phone can make calls, but install WhatsApp and it can message. Install Paytm and it can pay. Each MCP server adds a new ability to your AI.

Real-World Analogy - Swiggy Kitchen Partners:

Swiggy does not cook food. It connects customers to thousands of restaurants (partners). Each restaurant has its own menu and kitchen, but Swiggy provides the standard interface (app, delivery). MCP clients are like Swiggy - they do not have the tools themselves, they connect to MCP servers (restaurants) that do the actual work.

The MCP Server Ecosystem:

• 1000+ servers available on GitHub, npm, and the official MCP registry
• Official servers maintained by Anthropic: filesystem, GitHub, GitLab, Google Drive, Slack, PostgreSQL, etc.
• Community servers for everything from Jira to Notion to AWS to stock trading
• Custom servers you build for your own internal tools

What It Does:

The Filesystem MCP server gives your AI the ability to read, write, search, and manage files on your local computer. It is one of the most commonly used MCP servers because so much of our work involves files.

Available Tools:

• read_file: Read the contents of any file in allowed directories
• write_file: Create or overwrite a file
• edit_file: Make targeted edits to specific parts of a file
• list_directory: See all files and folders in a directory
• search_files: Search for files by name pattern across directories
• get_file_info: Get metadata like size, creation date, permissions
• move_file: Move or rename files
• create_directory: Create new folders

Security - Directory Allowlisting:

The filesystem server requires you to specify allowed directories. The AI can ONLY access files within those directories. If you allow /Users/you/projects, the AI cannot read /Users/you/passwords. This is a critical security boundary.

// Configuration example (Claude Desktop)
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem",
              "/Users/you/projects", "/Users/you/documents"]
    }
  }
}

Example Workflow:

You: "Read my package.json and tell me what dependencies are outdated"

AI Agent:
  1. Calls read_file("/Users/you/projects/app/package.json")
  2. Parses the JSON content
  3. Analyzes dependency versions
  4. Reports: "react is at 18.2, latest is 19.1. express at 4.18, latest is 5.0..."

What It Does:

The GitHub MCP server connects your AI to the GitHub API. It can manage repositories, pull requests, issues, code reviews, and more - all through natural language commands.

Key Tools Available:

• search_repositories: Find repos matching a query
• get_file_contents: Read files from any repo
• create_or_update_file: Commit changes directly
• create_pull_request: Open PRs with title, body, and branch
• list_issues / create_issue: Manage project issues
• push_files: Push multiple file changes in one commit
• create_branch: Create new branches from any ref
• search_code: Search code across all of GitHub

Configuration:

Requires a GitHub Personal Access Token with appropriate permissions:

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

Powerful Use Cases:

• "Review the latest PR on my repo and suggest improvements"
• "Create an issue for the bug I just found with reproduction steps"
• "Search all repos in our org for any usage of deprecated API v2"
• "Create a branch, fix the typo in README, and open a PR"

PostgreSQL / SQLite MCP Server:

Connect your AI directly to your database. It can inspect schemas, run SELECT queries, and analyze data - all through conversation. Perfect for data exploration and quick analytics.

• list_tables: See all tables in the database
• describe_table: Get column names, types, constraints
• read_query: Execute SELECT queries (read-only for safety)
• append_insight: Save analysis insights as memos

Important: Most DB servers are read-only by default. Write operations require explicit configuration. This prevents accidental data mutations.

Web Search & Browser MCP Servers:

Give your AI the ability to search and browse the web in real-time:

• Brave Search MCP: Web search using Brave API. Great for fact-checking and research.
• Fetch / Web MCP: Fetch and read any webpage content. AI can extract information from URLs.
• Puppeteer MCP: Full browser automation - click buttons, fill forms, take screenshots. For complex web interactions.

Configuration Examples:

// PostgreSQL MCP Server
{
  "postgres": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-postgres",
            "postgresql://user:pass@localhost/mydb"]
  }
}

// Brave Search MCP Server
{
  "brave-search": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-brave-search"],
    "env": {
      "BRAVE_API_KEY": "your_brave_api_key"
    }
  }
}

Example Interaction:

You: "How many users signed up last week? Compare with the week before."

AI Agent:
  1. Calls describe_table("users") to understand schema
  2. Calls read_query("SELECT COUNT(*) FROM users WHERE created_at > ...")
  3. Calls read_query again for the previous week
  4. Reports: "Last week: 342 signups. Week before: 289. That is 18% growth!"

The Power of Multiple Servers:

The real magic happens when you configure multiple MCP servers together. Each server adds capabilities, and the AI can chain them to solve complex tasks. It is like having a team of specialists that can collaborate.

Developer Workflow Setup:

Your AI has access to:
  - Filesystem MCP    (read/write local code)
  - GitHub MCP        (manage repos, PRs, issues)
  - PostgreSQL MCP    (query your dev database)
  - Brave Search MCP  (search web for docs)

Workflow Example:
You: "The login API is returning 500 errors.
      Check the error logs, find the bug, fix it,
      and create a PR."

AI Agent:
  1. Reads log files via Filesystem MCP
  2. Identifies the error: null pointer in auth middleware
  3. Searches web for the error pattern via Brave Search
  4. Reads the source file via Filesystem MCP
  5. Fixes the code and writes the file
  6. Creates a branch and PR via GitHub MCP
  7. Reports: "Fixed! PR #47 created with the auth fix."

Data Analyst Workflow:

Your AI has access to:
  - PostgreSQL MCP    (query analytics DB)
  - Filesystem MCP    (save reports)
  - Google Drive MCP  (upload to shared drive)

You: "Generate the monthly sales report for February
      and share it with the team."

AI Agent:
  1. Queries sales data via PostgreSQL MCP
  2. Calculates totals, comparisons, trends
  3. Writes a formatted report file via Filesystem MCP
  4. Uploads to shared drive via Google Drive MCP
  5. Reports: "February report generated and uploaded!"

Tips for Multi-Server Configuration:

• Each server is independent - if one crashes, others keep working
• Name servers clearly so you can identify them in logs
• Start with 2-3 servers and add more as needed. Too many servers can slow down initialization.
• Test each server individually before combining them

Rule 1: Principle of Least Privilege

Give each MCP server the minimum access it needs. Filesystem? Only specific directories. GitHub? Only necessary repos with read-only if possible. Database? Read-only user with SELECT permissions only. Never give admin access when viewer access is enough.

Rule 2: Protect Your Secrets

API tokens, database passwords, and access keys are configured in your MCP config file. Keep this file secure. Do not commit it to Git. Use environment variables when possible. Rotate tokens regularly.

Rule 3: Review Before Approve

Most MCP clients show you what tool the AI wants to call before executing it. Always review destructive operations like file writes, PR creation, or data mutations. Do not blindly approve tool calls you do not understand.

Rule 4: Use Official Servers First

The official MCP servers maintained by Anthropic are well-tested and security-reviewed. Community servers may have vulnerabilities. Always check the source code and popularity of community servers before using them.

Q: What is the role of pre-built MCP servers?

Q: How does the Filesystem MCP server handle security?

Q: Why are database MCP servers typically read-only by default?

Q: What happens when you configure multiple MCP servers together?

Q: What security best practices should you follow when configuring MCP servers?