The YouTube MCP provides these tools:
- videos_searchVideos - Search for videos
- videos_getVideo - Get video details
- transcripts_getTranscript - Get video transcript
- channels_getChannel - Get channel info
- channels_listVideos - List channel videos

Does this cover what you need?

{
  "mcpServers": {
    "youtube": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@kirbah/mcp-youtube"],
      "env": {
        "YOUTUBE_API_KEY": "AIzaSy...actual-key-here"
      }
    }
  }
}

{
  "youtube": {
    "type": "stdio",
    "command": "cmd",
    "args": ["/c", "npx", "-y", "@kirbah/mcp-youtube"],
    "env": {
      "YOUTUBE_API_KEY": "AIzaSy...actual-key-here"
    }
  }
}

{
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "Bash(git:*)",
      "Bash(npm:*)",
      "mcp__youtube__*"
    ]
  }
}

{
  "mcpServers": {
    "server-name": {
      "type": "http|sse|stdio",
      "url": "https://...",
      "command": "node|npx|python|uv",
      "args": ["arg1", "arg2"],
      "env": {
        "VAR_NAME": "value"
      },
      "headers": {
        "Authorization": "Bearer token"
      }
    }
  }
}

{
  "notion": {
    "type": "http",
    "url": "https://mcp.notion.com/mcp",
    "headers": {
      "Authorization": "Bearer ntn_...your-token"
    }
  }
}

{
  "youtube": {
    "type": "stdio",
    "command": "npx",
    "args": ["-y", "@kirbah/mcp-youtube"],
    "env": {
      "YOUTUBE_API_KEY": "AIzaSy...your-key"
    }
  }
}

{
  "youtube": {
    "type": "stdio",
    "command": "npx",
    "args": ["-y", "@kirbah/mcp-youtube"],
    "env": {
      "YOUTUBE_API_KEY": "your-api-key"
    }
  }
}

{
  "notion": {
    "type": "stdio",
    "command": "npx",
    "args": ["-y", "@notionhq/notion-mcp-server"],
    "env": {
      "NOTION_TOKEN": "your-integration-token"
    }
  }
}

claude mcp add --transport http github https://api.githubcopilot.com/mcp/

claude mcp add --transport stdio files -- npx -y @modelcontextprotocol/server-filesystem /path/to/dir

# Install uv (fast Python package manager)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Create project
uv init my-mcp-server
cd my-mcp-server
uv venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate

# Install MCP SDK
uv add "mcp[cli]" httpx

from mcp.server.fastmcp import FastMCP

# Create server
mcp = FastMCP("my-server")

@mcp.tool()
async def my_tool(param: str) -> str:
    """Description of what this tool does.

    Args:
        param: Description of this parameter
    """
    # Your implementation here
    return f"Result for {param}"

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

if __name__ == "__main__":
    main()

uv run server.py

mkdir my-mcp-server
cd my-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node

mkdir src

{
  "type": "module",
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js"
  }
}

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "my-server",
  version: "1.0.0",
});

// Register a tool
server.registerTool(
  "my_tool",
  {
    description: "Description of what this tool does",
    inputSchema: {
      type: "object",
      properties: {
        param: {
          type: "string",
          description: "Description of this parameter"
        }
      },
      required: ["param"]
    }
  },
  async ({ param }) => {
    // Your implementation here
    return {
      content: [{
        type: "text",
        text: `Result for ${param}`
      }]
    };
  }
);

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Server running on stdio");
}

main().catch(console.error);

npm run build
npm start

@mcp.tool()
async def search_products(query: str, limit: int = 10) -> str:
    """Search for products in the catalog.

    Args:
        query: Search terms
        limit: Maximum results to return (default 10)
    """
    # Call your API
    results = await api.search(query, limit)
    return json.dumps(results)

@mcp.tool()
async def get_order(order_id: str) -> str:
    """Get details for a specific order.

    Args:
        order_id: The order ID to look up
    """
    order = await api.get_order(order_id)
    return json.dumps(order)

server.registerTool(
  "search_products",
  {
    description: "Search for products in the catalog",
    inputSchema: {
      type: "object",
      properties: {
        query: { type: "string", description: "Search terms" },
        limit: { type: "number", description: "Max results", default: 10 }
      },
      required: ["query"]
    }
  },
  async ({ query, limit = 10 }) => {
    const results = await api.search(query, limit);
    return {
      content: [{ type: "text", text: JSON.stringify(results) }]
    };
  }
);

{
  "mcpServers": {
    "my-server": {
      "type": "stdio",
      "command": "uv",
      "args": ["--directory", "/absolute/path/to/my-mcp-server", "run", "server.py"],
      "env": {
        "API_KEY": "your-api-key"
      }
    }
  }
}

{
  "mcpServers": {
    "my-server": {
      "type": "stdio",
      "command": "node",
      "args": ["/absolute/path/to/my-mcp-server/dist/index.js"],
      "env": {
        "API_KEY": "your-api-key"
      }
    }
  }
}

# BAD - breaks JSON-RPC
print("Processing...")

# GOOD - use stderr or logging
import logging
logging.info("Processing...")

// BAD
console.log("Started");

// GOOD
console.error("Started");  // stderr is safe

my-mcp-server/
├── server.py          # Main server (Python)
├── src/
│   └── index.ts       # Main server (TypeScript)
├── package.json       # (TypeScript)
├── pyproject.toml     # (Python)
└── README.md          # How to use