MCP Servers

One protocol connects your AI to calendars, databases, file systems, APIs, and any custom tools—all using the same interface.

Each integration requires custom code, different authentication flows, unique data formats, and separate maintenance.

• search_flights — Query available flights between cities

• send_message — Post a message to Slack or Discord

• create_calendar_event — Add an event to Google Calendar

• execute_query — Run a SQL query on your database

• deploy_function — Deploy code to a cloud platform

• file:///documents/report.pdf — A local file

• postgres://mydb/schema — Database schema information

• github://repo/README.md — Repository documentation

• calendar://events/today — Today's scheduled events

• "Plan a vacation" — Combines calendar resources, flight search tools, and hotel booking tools

• "Code review" — Uses file resources, linting tools, and documentation resources

• "Daily standup" — Pulls from project management resources and drafts status updates

A Filesystem Server with access to your project folder enables the AI to:

• Read source files and understand project structure

• Analyze dependencies from package.json or requirements.txt

• Search for patterns across the codebase

• Create or modify files based on instructions

Combined with a Git tool, it can also commit changes and create pull requests.

• Define available Tools with schemas describing parameters and return types

• Expose Resources with URIs and content types

• Handle authentication for sensitive operations

• Execute logic when tools are invoked

• Return structured responses the client can process

Best for: Local, desktop-based applications

• Simpler setup—runs as a subprocess

• Used by Claude Desktop, VS Code extensions

• No network configuration required

• Process communication via standard input/output

Best for: Remote, web-based applications

• Enables cloud-hosted MCP servers

• Supports multiple concurrent clients

• Requires API endpoints and CORS configuration

• Needs proper authentication (OAuth 2.1)

• Discover servers and their capabilities

• Present tools to the AI model for decision-making

• Fetch resources to provide context

• Handle user approval for sensitive tool executions

• Display results back to the user

from mcp.server.fastmcp import FastMCP

# Create a server instance
mcp = FastMCP("weather-server")

# Define a tool the AI can call
@mcp.tool()
def get_forecast(city: str, days: int = 5) -> dict:
  """Get weather forecast for a city."""
  return {
      "city": city,
      "forecast": [
          {"day": 1, "temp": 72, "conditions": "Sunny"},
          {"day": 2, "temp": 68, "conditions": "Partly Cloudy"},
      ]
  }

# Define a resource for current conditions
@mcp.resource("weather://current/{city}")
def current_weather(city: str) -> str:
  """Current weather conditions for a city."""
  return f"Temperature: 70°F, Humidity: 45%, Conditions: Clear"

# Run the server
if __name__ == "__main__":
  mcp.run()

{
"mcpServers": {
  "weather": {
    "command": "python",
    "args": ["/path/to/weather_server.py"]
  }
}
}

1. Client connects to your protected server

2. Server responds with 401 Unauthorized + link to Protected Resource Metadata

3. Client reads PRM and discovers the Authorization Server (e.g., Auth0, Keycloak)

4. User logs in via browser and grants consent to required scopes

5. Client receives an Access Token

6. All future requests include the token for validation

# Tools with sensitive operations should be marked
# The MCP client will prompt user approval before execution

@mcp.tool()
def send_email(to: str, subject: str, body: str) -> str:
  """Send an email. Client will request user approval."""
  # This only runs after user approves in the client UI
  return email_service.send(to, subject, body)

A "Book Hotel" tool might pause mid-execution to ask:

"What is your preferred room type? (Sea view / City view / Standard)"

The user's response is passed back to the tool to continue processing.

// Client configuration restricts server filesystem access
{
"roots": [
  "file:///Users/me/projects/current-project",
  "file:///Users/me/documents/work"
]
}
// The server can only access files within these directories

A flight search tool returns 100 options. Instead of dumping all data:

1. Server processes the raw results

2. Server "samples" the client's LLM: "Summarize the top 5 flights by price and convenience"

3. Client's AI generates the summary

4. Server returns the polished result

This leverages the client's AI for summarization while keeping data processing on the server.

1. Install Claude Desktop — It has built-in MCP client support

2. Follow the quickstart guide — Build a simple local server in Python or TypeScript

3. Connect to Claude — See your tools appear in conversation

4. Iterate — Add more tools and resources as needed

• Use HTTP/SSE transport for remote accessibility

• Implement OAuth 2.1 for authentication

• Add rate limiting and usage quotas

• Enable logging and monitoring

• Define clear tool schemas with validation

• Require approval for sensitive operations

• Test with various client implementations

• Filesystem — Read/write local files

• GitHub — Repository access, issue management

• PostgreSQL — Database queries and schema exploration

• Slack — Messaging and channel management

• Google Drive — Document access and search

• Brave Search — Web search capabilities

• Memory — Persistent knowledge storage

• Tools let AI perform actions (model-controlled)

• Resources give AI context (application-controlled)

• Prompts define reusable workflows (user-controlled)

• STDIO for local servers, HTTP/SSE for remote

• OAuth 2.1 secures production deployments

• Human-in-the-loop ensures safe sensitive operations