MCP with Claude: Basics, Quick Tutorial, and Top 10 MCP Servers

What Is Model Context Protocol? 

Model Context Protocol (MCP) is an open-source standard from Anthropic that allows AI models, including Claude, to securely interact with local data, external tools, and databases, such as GitHub, Google Drive, or Slack. It functions as a connector (“bridge”) for components like Claude Desktop or Claude Code, enabling capabilities like reading files, querying SQL databases, and executing code.

MCP defines a common interface and communication framework, often compared to a “USB-C” for AI, so models such as Claude or ChatGPT can access real-time information, execute actions through APIs, retrieve files, and interact with applications without bespoke integrations for each system. 

MCP uses a client-server architecture in which the AI host (e.g., a chatbot) communicates with MCP servers that expose resources, tools, and workflows in a structured way, enabling dynamic, context-aware behavior across platforms.

Why Model Context Protocol Matters for Claude-based Systems 

Model Context Protocol is especially important for systems built on Claude because it expands these AI models beyond isolated text generators into integrated agents that can perform real-world tasks. With MCP, Claude can access up-to-date data and tools inside enterprise systems, productivity apps, databases, and desktop environments, making its responses more accurate and relevant to the user’s context.

MCP reduces the development burden of writing custom connectors for each tool, accelerates integration with third-party services, and enables a richer, interactive experience—such as drafting Slack messages or updating project management platforms directly within a Claude session. In broader terms, adopting MCP fosters an interoperable ecosystem where AI assistants aren’t siloed but can act on behalf of users across diverse applications, a key capability for advanced AI agents and enterprise-grade workflows.

Use Cases of Claude with MCP Integration 

Workflow Automation and Productivity Improvements

Using MCP, Claude can interact with calendars, email systems, task managers, and document editors through standardized interfaces. For example, a user can ask Claude to summarize unread emails, schedule meetings based on availability across participants, or auto-generate weekly reports from data in spreadsheets and project trackers.

Because MCP allows Claude to act as an intermediary between systems like Google Workspace, Microsoft 365, and enterprise CRMs, it reduces friction in cross-application workflows. This enables users to orchestrate complex tasks (such as drafting follow-up messages based on CRM activity or updating tasks based on meeting notes_ without switching between tools or writing glue code.

Real-Time External Data Access for Context and Analysis

MCP allows Claude to query APIs, pull in structured data, and fetch live updates from external services as part of its reasoning process. This means Claude can incorporate current stock prices, weather conditions, or system health metrics directly into its responses without pretraining on that data.

In enterprise use cases, Claude can retrieve real-time metrics from business dashboards, perform on-demand database queries, or generate summaries of logs and alerts. This bridges the gap between static model knowledge and dynamic environments, allowing Claude to generate contextually accurate outputs grounded in the most recent information available.

Development and Coding Workflows via Claude Code

With MCP integrations, Claude can connect to code repositories, build tools, issue trackers, and development environments to assist with real-world programming tasks. It can search codebases, suggest pull request changes, or generate boilerplate code based on current project structures and standards.

Claude can also interact with CI/CD pipelines to trigger builds, run tests, or analyze failures through natural language prompts. This turns it into a developer co-pilot that doesn’t just suggest code, but operates within the developer’s actual toolchain, improving automation, consistency, and developer velocity.

Try Obot Today

⬇️ Download the Obot open-source gateway on GitHub and begin integrating your systems with a secure, extensible MCP foundation.

Quick Tutorial: Connecting Claude Code to Tools via MCP 

Installing MCP Servers

To connect Claude Code to external tools using the Model Context Protocol (MCP), you must configure MCP servers. These servers act as bridges between Claude and third-party APIs or services. There are three supported transport types:

1. Remote HTTP Servers

This is the recommended and most widely supported option, especially for cloud-based services. You can add an HTTP server with the following command:

claude mcp add --transport http <name> <url>

For example, to connect to Notion:

claude mcp add --transport http notion https://mcp.notion.com/mcp

You can also include authentication headers:

claude mcp add --transport http secure-api https://api.example.com/mcp \    --header "Authorization: Bearer your-token"

2. Remote SSE Servers

This transport is deprecated and should only be used when HTTP is not available. It follows a similar syntax:

claude mcp add --transport sse <name> <url>

Example:

claude mcp add --transport sse asana https://mcp.asana.com/sse

3. Local stdio Servers

These run locally and are useful for direct system access or running custom scripts. Use a double dash (–) to separate configuration flags from the command:

claude mcp add --transport stdio <name> -- <command> [args...]

Example:

claude mcp add --transport stdio --env AIRTABLE_API_KEY=YOUR_KEY airtable \`    -- npx -y airtable-mcp-server

On Windows (non-WSL), you must use cmd /c to execute commands like npx:

claude mcp add --transport stdio my-server -- cmd /c npx -y @some/package

Additional options:

• Use --header for authentication
• Use --env to set environment variables
• Use MCP_TIMEOUT to configure startup timeout
• Use MAX_MCP_OUTPUT_TOKENS to increase output token limits

To manage MCP servers:

claude mcp list         # List all servers

claude mcp get <name>   # Get server details

claude mcp remove <name>  # Remove server

Claude Code also supports dynamic tool updates via list_changed notifications, allowing servers to push tool changes without a manual reconnect.

MCP Installation Scopes

When you add an MCP server, you must choose its scope. The scope determines who can access the server and in which contexts. There are three scopes:

1. Local Scope (Default)

Servers are stored in ~/.claude.json and are private to your user within the current project. These are useful for personal testing or tools that include sensitive credentials.

Example:

claude mcp add --transport http stripe https://mcp.stripe.com

Or explicitly:

claude mcp add --transport http stripe --scope local https://mcp.stripe.com

2. Project Scope

Servers are defined in .mcp.json at the root of the project and are meant to be shared across the team. These configs can be committed to version control. Claude Code will prompt for confirmation before using shared servers from this file.

Example:

claude mcp add --transport http paypal --scope project https://mcp.paypal.com/mcp

3. User Scope

User-scoped servers are also stored in ~/.claude.json but are accessible across all projects on your system. Use this for tools you frequently access.

Example:

claude mcp add --transport http hubspot --scope user https://mcp.hubspot.com/anthropic

Scope Precedence

 If servers share the same name across scopes, Claude prioritizes them in the following order:

1. Local
2. Project
3. User

Environment Variable Expansion

 .mcp.json files support environment variable interpolation, allowing flexible and secure configurations across environments.

Example:

{    "mcpServers": {      "api-server": {        "type": "http",        "url": "${API_BASE_URL:-https://api.example.com}/mcp",        "headers": {          "Authorization": "Bearer ${API_KEY}"        }      }    }  }

If a required variable isn’t set and has no default, the configuration will fail to load.

Notable Claude MCP Servers

Claude Code can be extended with a range of Model Context Protocol (MCP) servers, each unlocking capabilities that let Claude interact with tools, APIs, and data. Below is a breakdown of key MCP servers and what they enable Claude to do.

1. GitHub MCP Server

GitHub MCP integrates Claude with GitHub’s API, enabling it to perform source control and DevOps tasks across repositories and teams.

Key capabilities:

• Read and analyze pull requests and issues: Claude can surface open issues by label, summarize PRs, or identify merge conflicts.
• Trigger CI/CD workflows: Start GitHub Actions runs, check status, or analyze failed jobs directly through prompts.
• Search repositories for context: Claude can find function definitions, code examples, or references within the repo history.
• Create or update issues: Generate bug reports, document feature ideas, or post code review comments without switching tools.
• OAuth-based access: Connect securely with an organization’s GitHub account through a browser-based flow.

Setup:

Install the MCP package and configure GitHub:

npm install @composio/mcp@latest  npx @composio/mcp@latest setup github --client claude

Then authenticate via OAuth in Claude Code settings and restart Claude Code.

Example:

Prompt in Claude Code:

Find all issues about authentication.

Claude retrieves matching issues directly from GitHub without leaving the terminal.

2. Apidog MCP Server

Apidog bridges Claude to live API specs, so it always generates and validates code against an organization’s real contract definitions.

Key capabilities:

• Load OpenAPI/Swagger specs from local files or remote URLs, including those hosted in Apidog projects.
• Generate client code such as TypeScript interfaces, Retrofit clients, or Java Spring controllers that match the user’s API definitions.
• Create mock servers or test stubs to simulate API responses during development.
• Update code with spec changes: Claude can refresh its understanding when the API evolves, reducing integration errors.
• Supports local and remote setups, including command-line integration via npx or JSON-based project configuration.

Setup:

Local OpenAPI File – macOS/Linux:

Add this to mcp.json:

{   "mcpServers": {     "API specification": {       "command": "npx",       "args": [         "-y",         "apidog-mcp-server@latest",         "--oas=<oas-url-or-path>"       ]     }   }  }

Windows configuration:

{   "mcpServers": {     "API specification": {       "command": "cmd",       "args": [         "/c",         "npx",         "-y",         "apidog-mcp-server@latest",         "--oas=<oas-url-or-path>"       ]     }   }  }

Restart Claude Code and test by requesting an endpoint specification.

Example:

Generate Java records for the Product schema based on the API specification.

Claude reads the spec and generates code aligned with the contract.

3. File System MCP Server

This server allows Claude to directly interact with the local file system, automating routine edits and data extraction.

Key capabilities:

• Read and write files using natural commands like “Add a license header to all .ts files.”
• Edit or refactor code across multiple files, such as renaming variables or splitting modules.
• Search project files by content or path, enabling Claude to answer questions like “Where is this function defined?”
• Perform batch operations like cleaning logs, converting formats, or generating scaffolding.

Setup:

git clone https://github.com/modelcontextprotocol/servers.git  cd servers/src/filesystem  npm install

Then configure it in claude_desktop_config.json and restart Claude Code.

Example:

Update the README.md with a new section describing deployment steps.

Claude edits the file directly.

4. Sequential Thinking MCP Server

Sequential Thinking enables Claude to deconstruct complex problems into logical steps with memory across each decision.

Key capabilities:

• Break down large tasks like architectural planning, refactoring strategies, or feature rollout design.
• Explore alternatives simultaneously by evaluating multiple paths before making a recommendation.
• Revise earlier assumptions mid-way through reasoning when new information becomes available.
• Great for ambiguous or open-ended problems where context evolves during discussion.

Setup:

npm install -g @modelcontextprotocol/server-sequential-thinking

Add to claude_desktop_config.json:

{   "mcpServers": {     "sequential-thinking": {       "command": "node",       "args": ["sequential-thinking.js"]     }   }  }

Restart Claude Code.

Example:

Break down the steps to refactor this module.

Claude produces a structured, step-by-step plan.

5. Puppeteer MCP Server

This server connects Claude to a headless browser controlled via Puppeteer, enabling high-fidelity web automation and testing.

Key capabilities:

• Automate website navigation and interactions, including login flows, form submissions, or multi-page actions.
• Capture structured data by selecting DOM elements with precision using semantic roles and selectors.
• Take full-page screenshots for visual validation or UI documentation.
• Run headless tests as part of a local or CI-based workflow without needing a browser GUI.

Setup:

npm install puppeteer

Clone the server repository, install dependencies, configure Claude Code, and restart.

Example:

Take a screenshot of this webpage.

Claude controls the browser and returns the result.

6. PostgreSQL MCP Server

This server gives Claude access to PostgreSQL databases, allowing it to perform SQL queries and interact with structured data using natural language.

Key capabilities:

• Convert prompts to SQL: Claude can generate SELECT, INSERT, or JOIN queries based on the desired schema.
• Query live databases to summarize metrics, generate reports, or check values.
• Perform CRUD operations safely by validating commands before execution.
• Analyze query results and format outputs as tables, charts, or summaries.

Setup:

git clone https://github.com/modelcontextprotocol/servers.git  cd servers/src/postgres  npm install

Configure the server with database credentials and restart Claude Code.

Example:

Summarize sales data from the past month.

Claude translates the request into SQL and returns formatted results.

7. Notion MCP Server

The official Notion server allows Claude to interact with Notion workspaces, turning it into a knowledge management and documentation assistant.

Key capabilities:

• Read from pages and databases, such as fetching meeting notes, specs, or task lists.
• Create and edit Notion pages using structured input, great for documenting decisions or planning sprints.
• Search content using filters like title, tags, or last edited time to retrieve relevant records.
• Comment on pages or updates directly from Claude to enable asynchronous collaboration.

Setup:

npx @composio/mcp@latest setup notion --client claude

Authenticate via OAuth and restart Claude Code.

Example:

Add a new task to Notion for code review.

Claude creates the task directly in Notion.

8. Memory Bank MCP Server

This server equips Claude with persistent memory across sessions, enabling continuity and long-term awareness of project details.

Key capabilities:

• Store custom context like project goals, naming conventions, or decision histories.
• Recall previous conversations or actions, helping reduce repetition in long-term work.
• Useful for multi-stage workflows where Claude needs to remember past design choices or tool configurations.
• Local installation ensures data privacy while giving the model a working memory scope.

Setup:

git clone https://github.com/modelcontextprotocol/server-memory.git  npm install

Configure and restart Claude Code.

Example:

Resume work on the last module I edited.

Claude recalls prior context and continues the workflow.

9. Figma MCP Server

The Figma MCP server connects Claude to a local Figma Dev Mode session, allowing it to generate accurate, framework-specific code from design files.

Key capabilities:

• Convert selected frames into code such as React components, styled containers, or HTML/CSS snippets.
• Extract design tokens and variables for consistent theming across the codebase.
• Understand component mappings via Code Connect, aligning output with the organization’s design system.
• Runs locally via Figma desktop, ensuring secure, fast access to design data.

Setup:

npx @composio/mcp@latest setup figma --client claude

Authenticate via OAuth in Claude Code.

Example:

Convert this Figma layout to React components.

Claude generates UI code based on the design.

10. Zapier MCP Server

The Zapier server empowers Claude to automate workflows across an array of SaaS tools, acting as a no-code bridge for cross-app actions.

Key capabilities:

• Trigger actions in hundreds of apps, like sending a Slack message when a GitHub PR is opened.
• Read and write data to tools like Google Sheets, Trello, and Gmail.
• Automate status updates, alerts, or report generation as part of daily dev routines.
• Securely authenticate using Claude’s OAuth setup, with no need for hardcoded keys.

Setup:

npx @composio/mcp@latest setup zapier --client claude

Authenticate with Zapier and restart Claude Code.

Example:

Send a Slack message when a new PR is opened.

Claude configures or triggers cross-app automation through Zapier.

Related content: Read our guide to MCP tools

Managing MCP Servers and Workflows with Obot

If you’re evaluating Claude MCP for internal tools, developer workflows, or cross-app automation, Obot gives you a practical way to centralize and extend those integrations. Explore the open-source project and try it in your environment.

Obot helps teams move from one-off server setup to a managed MCP gateway with clearer access patterns, easier integration across systems, and a better foundation for production workflows. Read the whitepaper for the full picture on MCP adoption and maturity framework.

Get Started with Obot

Try Obot on GitHub · Get a demo · Read the docs