MCP Server Guide: 10 Integrations That Give Claude Code Superpowers (GitHub, Linear, Slack, Postgres, Salesforce...)

AI coding assistants in 2023-2024 lived inside a paradox: the models got smarter while their access to actual developer reality — your Linear tickets, your Postgres schema, your Slack threads — remained brittle and bespoke. Every integration was a custom-built bridge, every bridge a maintenance burden.

In November 2024, Anthropic open-sourced the Model Context Protocol (MCP). Within a year it became the de-facto standard for AI assistant integrations. Cursor, VS Code Copilot, Windsurf, Continue.dev — all consume MCP servers. As of May 2026, Anthropic's official MCP registry lists 300+ community servers, and GitHub indexes 5,000+ projects under the "mcp-server" topic.

Why It Matters

In the pre-MCP world, asking an AI assistant to "list my critical Linear bugs and open GitHub PRs for them" required separately written integrations. With MCP, the same assistant connects to two MCP servers and uses both in natural language. Enterprise AI's "tool use" problem is now largely solved.

2.1. Tools

Functions the assistant can invoke. Examples: create_issue, list_pull_requests, query_database. Each tool defines parameters via JSON Schema; the assistant produces them as model output and the MCP server executes.

2.2. Resources

File-like content the assistant can read. Examples: a Notion page, a Postgres table schema, a GitHub README. Resources are identified by URI (notion://page/abc123).

2.3. Prompts

Templates the server suggests to the user. Example: GitHub MCP may expose an analyze_pr prompt — the user clicks it and provides a PR number.

2.4. Transport Layer

MCP supports two transports:

• stdio: Local process IPC (most common, Claude Code default).
• HTTP+SSE / Streamable HTTP: Remote servers (enterprise deployment).

The newer Streamable HTTP transport, added in 2026, has begun replacing SSE — fewer connections, better failover.

Practical takeaway. The same MCP server (e.g., GitHub MCP) runs on all of these assistants — you just add it to each config file. This makes enterprise standardization easy: write once, use everywhere.

4.1. Config Files

Claude Code supports three config levels:

1. User-level: ~/.claude.json — servers shared across all projects.
2. Project-level: .mcp.json (at repo root) — project-specific, committed to repo.
3. Local-only: .mcp.local.json — gitignored, secrets allowed.

4.2. CLI Commands

Claude Code 2.0+ MCP CLI:

# Add a new MCP server interactively
claude mcp add github

# Add via JSON config
claude mcp add --json '{"name":"github","command":"npx","args":["-y","@modelcontextprotocol/server-github"],"env":{"GITHUB_PERSONAL_ACCESS_TOKEN":"ghp_xxx"}}'

# List all servers
claude mcp list

# Test a specific server
claude mcp test github

# Remove
claude mcp remove github

4.3. Slash Commands

From inside Claude Code:

• /mcp — see all connected servers and their tools.
• /mcp __tools — detailed tool listing per server.
• /mcp restart <server> — restart a server.

The most widely deployed, enterprise-grade, ecosystem-vetted MCP servers as of 2026.

5.1. GitHub MCP Server

The #1 developer-assistant integration. Issues, PRs, code search, CI status, code review — all in one server.

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

Recommended PAT scope: repo, read:org, read:user. Use fine-grained PAT to limit specific repos.

Example prompts:

• "List my unmerged PRs from the last 7 days; which are waiting for review?"
• "Find all open issues that reference auth.ts in this repo."
• "Summarize the last 5 commits on feature/payment-flow."

Cost. Typical query 2K-15K tokens; complex search 30K+. GitHub API quota: 5,000 req/hour per PAT.

5.2. Linear MCP Server

Linear adoption in modern engineering teams crossed 60% by 2026; ticket-to-PR flow is natural.

{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "@linear/mcp-server"],
      "env": { "LINEAR_API_KEY": "lin_api_xxx" }
    }
  }
}

Tools: list_issues, create_issue, update_issue, add_comment, search_issues (Linear DSL).

Example prompts:

• "List my P0/P1 tickets in this sprint and summarize each one's latest update."
• "Analyze PR #1234 and post a comment on the related Linear ticket."

5.3. Slack MCP Server

70% of engineering discussions happen in Slack; access to history is critical context.

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": { "SLACK_BOT_TOKEN": "xoxb-xxx", "SLACK_TEAM_ID": "T01234567" }
    }
  }
}

App scopes: channels:history, channels:read, chat:write, users:read. Bot token (xoxb-) is preferred.

5.4. PostgreSQL MCP Server

The most critical assistant tool: without schema knowledge, the model cannot write accurate SQL/ORM code.

CRITICAL security. Always use a read-only user. An LLM accidentally running DROP TABLE is catastrophic.

CREATE ROLE ai_readonly WITH LOGIN PASSWORD 'xxx';
GRANT CONNECT ON DATABASE mydb TO ai_readonly;
GRANT USAGE ON SCHEMA public TO ai_readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO ai_readonly;

5.5. Salesforce MCP Server

Customer data lives in Salesforce; sales-marketing automation benefits enormously from assistant integration.

{
  "mcpServers": {
    "salesforce": {
      "command": "npx",
      "args": ["-y", "@salesforce/mcp-server"],
      "env": {
        "SALESFORCE_USERNAME": "you@company.com",
        "SALESFORCE_PASSWORD": "xxx",
        "SALESFORCE_SECURITY_TOKEN": "yyy"
      }
    }
  }
}

KVKK note. Salesforce contains personal data; calls travel to OpenAI/Anthropic cloud. For KVKK compliance in Turkey: (1) explicit consent for cross-border transfer, (2) PII masking layer between Salesforce and the MCP server, or (3) self-hosted Claude (Bedrock in Turkey region).

5.6. BigQuery MCP Server

Analytics warehouse — bigger role than Postgres for data teams.

Recommended service account roles: roles/bigquery.dataViewer, roles/bigquery.jobUser. No write privileges.

Tip. Use dry_run tool to estimate query cost before execution; add a system prompt rule: "Always dry_run before run_query if expected scan > 10GB."

5.7. Figma MCP Server

Design-to-code bridge for frontend developers; direct component generation from Figma frames.

{
  "mcpServers": {
    "figma": {
      "command": "npx",
      "args": ["-y", "@figma/mcp-server"],
      "env": { "FIGMA_ACCESS_TOKEN": "figd_xxx" }
    }
  }
}

Tools: get_file, get_frame_image, get_component_styles, export_assets.

5.8. Notion MCP Server

Popular as a documentation platform; spec-to-code flow is critical.

Tools: search_pages, get_page, create_page, query_database.

5.9. Confluence MCP Server

For enterprise customers using Atlassian instead of Notion — standard at large banks and enterprise IT.

{
  "mcpServers": {
    "confluence": {
      "command": "npx",
      "args": ["-y", "@atlassian/mcp-server-confluence"],
      "env": {
        "CONFLUENCE_URL": "https://yourcompany.atlassian.net/wiki",
        "CONFLUENCE_EMAIL": "you@company.com",
        "CONFLUENCE_API_TOKEN": "ATATT_xxx"
      }
    }
  }
}

5.10. Filesystem MCP Server

Sandboxed local file access. Claude Code already reads/writes files, but the Filesystem MCP gives stricter isolation via allowed paths.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/you/projects",
        "/Users/you/Downloads"
      ]
    }
  }
}

Security. Keep allowed paths tight. / or ~/ is not a feature, it's a risk.

The Turkish ecosystem is wide open: KVKK MCP (data protection queries), Yargıtay MCP (case-law search), e-Fatura MCP (e-invoice lookups). Here is a minimal example for a KVKK Decision Archive server.

#!/usr/bin/env node
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { z } from "zod";

const server = new Server(
  { name: "kvkk-mcp-server", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

const SearchSchema = z.object({
  query: z.string(),
  yearFrom: z.number().optional(),
  yearTo: z.number().optional(),
});

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "search_kvkk_decisions",
      description: "Full-text search over KVKK Board decisions.",
      inputSchema: {
        type: "object",
        properties: {
          query: { type: "string" },
          yearFrom: { type: "number" },
          yearTo: { type: "number" },
        },
        required: ["query"],
      },
    },
  ],
}));

server.setRequestHandler(CallToolRequestSchema, async (req) => {
  if (req.params.name === "search_kvkk_decisions") {
    const args = SearchSchema.parse(req.params.arguments);
    const results = await searchKVKKDB(args);
    return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
  }
  throw new Error("Unknown tool");
});

const transport = new StdioServerTransport();
await server.connect(transport);

200-500 lines covers a production-ready MCP server. Domain-specific Turkish servers are nearly absent in the registry — first movers can define the standard.

Monthly cost for a 10-developer team:

• Claude Pro $20/dev → $200/month, MCP tool usage included.
• Claude Max 5x $100/dev for heavy users; hooks, subagents, MCP unlimited.
• Claude Max 20x $200/dev for full agent autonomy.
• Direct API: $80-$300/dev/month depending on intensity.

KVKK Risk

MCP servers access systems containing personal data (Salesforce, Postgres). For KVKK compliance:

1. Read-only access — model cannot accidentally write/delete.
2. PII masking layer — MCP server returns masked data; raw PII never leaves the perimeter.
3. Cross-border transfer consent — required by KVKK Article 9 for foreign LLM calls.
4. Audit logs — every MCP call (tool, args, result) stored for compliance.

Ecosystem Opportunities

These MCP servers do not yet exist and the first mover sets the standard:

• KVKK Decision Archive
• Yargıtay (Supreme Court) case-law search
• e-Fatura (e-invoice) lookup
• MERNIS identity verification (licensed institutions)
• Sayıştay public audit reports
• MASAK financial-crime public lists

Profile. 35-person fintech in Istanbul: 18 backend, 8 frontend, 5 data, 4 DevOps.

Problem. Constant context switching: Linear → GitHub → Postgres → Slack → Notion. 4-5 tool switches per hour; deep focus collapsed.

Solution. Three phases:

• Phase 1 (1 week): GitHub + Linear + Slack MCP — Claude Code Pro for everyone.
• Phase 2 (2 weeks): Postgres (read-only) + Notion for backend and data teams.
• Phase 3 (3 weeks): Custom MCP for internal tools (deploy CLI, feature flags).

Results (3 months later).

• Ticket-to-PR time: 36h → 9h (4x).
• Code review cycle: 18h → 7h.
• Developer satisfaction (1-10): 6.4 → 8.1.
• New-dev onboarding: 12 days → 5 days.

Lesson. "MCP's value is not only individual productivity — it's team context sharing. When Claude reads one developer's recent ticket, it understands what the rest of the team is doing."

Tool Poisoning

A malicious third-party MCP server could expose tools that quietly delete data.

Mitigation: Use only official or trusted community servers; read source before npm i.

Prompt Injection via Resources

Embedded instructions in a Notion page or GitHub issue can hijack the assistant when it "reads the page."

Mitigation: Require manual approval for high-risk tools (write ops). Use --permission-prompt-tool in Claude Code.

Credential Leakage

Plaintext tokens in .mcp.json committed to repo — catastrophic.

Mitigation: Commit .mcp.json shell with empty env; secrets in .mcp.local.json (gitignored), or OS keychain integration.

Scope Creep

A token granted narrow scope grows over time until it becomes organization admin.

Mitigation: Quarterly audit; rotate PATs every 90 days with minimum required scope.

To stand up MCP integrations or design your enterprise-grade AI tool ecosystem:

1. MCP Strategy Workshop. A 4-hour session mapping your team's daily tool flow into a phased MCP integration roadmap (8-12 weeks).
2. Custom MCP Server Development. Turkish ecosystem (KVKK, e-Fatura, Yargıtay) or internal-tool MCP design and implementation.
3. MCP Security Audit. Evaluation of tool poisoning, prompt injection, credential leakage, scope creep in your current MCP setup; KVKK compliance gap analysis.

Use the contact form on the site to reach out.

This guide is a living document; the MCP ecosystem (new official servers, transport updates, security best practices) expands monthly, so it is refreshed monthly.