YouTube Toolbox
The YouTube Toolbox server provides AI assistants with powerful tools to interact with YouTube data and video content, including:
Search YouTube videos with advanced filtering options (channel, duration, region, etc.)
Get detailed information about videos and channels
Retrieve video comments with sorting options
Extract video transcripts and captions in multiple languages
Find related videos for a given video
Get trending videos by region
Generate summaries of video content based on transcripts
Advanced transcript analysis with filtering, searching, multi-video capabilities, and segmenting options
Leverages Google Cloud Platform services, specifically requiring YouTube Data API v3 credentials for authentication and access to YouTube data.
Provides tools for interacting with YouTube, including video searching, transcript extraction, comment retrieval, related video discovery, trending video lists, channel information retrieval, and transcript analysis with filtering and summarization capabilities.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@YouTube Toolboxsearch for Python tutorial videos from the last month"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
py-mcp-youtube-toolbox
An MCP server that provides AI assistants with powerful tools to interact with YouTube, including video searching, transcript extraction, comment retrieval, and more.
Overview
py-mcp-youtube-toolbox provides the following YouTube-related functionalities:
Search YouTube videos with advanced filtering options
Get detailed information about videos and channels
Retrieve video comments with sorting options
Extract video transcripts and captions in multiple languages
Find related videos for a given video
Get trending videos by region
Generate summaries of video content based on transcripts
Advanced transcript analysis with filtering, searching, and multi-video capabilities
Related MCP server: YouTube MCP Server
Table of Contents
Prerequisites
Python: Install Python 3.12 or higher
YouTube API Key:
Go to Google Cloud Console
Create a new project or select an existing one
Enable the YouTube Data API v3:
Go to "APIs & Services" > "Library"
Search for and enable "YouTube Data API v3"
Create credentials:
Go to "APIs & Services" > "Credentials"
Click "Create Credentials" > "API key"
Note down your API key
Installation
Git Clone
git clone https://github.com/jikime/py-mcp-youtube-toolbox.git
cd py-mcp-youtube-toolboxConfiguration
Install UV package manager:
curl -LsSf https://astral.sh/uv/install.sh | shCreate and activate virtual environment:
uv venv -p 3.12
source .venv/bin/activate # On MacOS/Linux
# or
.venv\Scripts\activate # On WindowsInstall dependencies:
uv pip install -r requirements.txtEnvironment variables:
cp env.example .env
vi .env
# Update with your YouTube API key
YOUTUBE_API_KEY=your_youtube_api_keyUsing Docker
Build the Docker image:
docker build -t py-mcp-youtube-toolbox .Run the container:
docker run -e YOUTUBE_API_KEY=your_youtube_api_key py-mcp-youtube-toolboxUsing Local
Run the server:
mcp run server.pyRun the MCP Inspector:
mcp dev server.pyConfigure MCP Settings
Add the server configuration to your MCP settings file:
Claude desktop app
To install automatically via Smithery:
npx -y @smithery/cli install @jikime/py-mcp-youtube-toolbox --client claudeTo install manually open
~/Library/Application Support/Claude/claude_desktop_config.json
Add this to the mcpServers object:
{
"mcpServers": {
"YouTube Toolbox": {
"command": "/path/to/bin/uv",
"args": [
"--directory",
"/path/to/py-mcp-youtube-toolbox",
"run",
"server.py"
],
"env": {
"YOUTUBE_API_KEY": "your_youtube_api_key"
}
}
}
}Cursor IDE
open ~/.cursor/mcp.json
Add this to the mcpServers object:
{
"mcpServers": {
"YouTube Toolbox": {
"command": "/path/to/bin/uv",
"args": [
"--directory",
"/path/to/py-mcp-youtube-toolbox",
"run",
"server.py"
],
"env": {
"YOUTUBE_API_KEY": "your_youtube_api_key"
}
}
}
}for Docker
{
"mcpServers": {
"YouTube Toolbox": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"-e", "YOUTUBE_API_KEY=your_youtube_api_key",
"py-mcp-youtube-toolbox"
]
}
}
}Tools Documentation
Video Tools
search_videos: Search for YouTube videos with advanced filtering options (channel, duration, region, etc.)get_video_details: Get detailed information about a specific YouTube video (title, channel, views, likes, etc.)get_video_comments: Retrieve comments from a YouTube video with sorting optionsget_related_videos: Find videos related to a specific YouTube videoget_trending_videos: Get trending videos on YouTube by region
Channel Tools
get_channel_details: Get detailed information about a YouTube channel (name, subscribers, views, etc.)
Transcript Tools
get_video_transcript: Extract transcripts/captions from YouTube videos in specified languagesget_video_enhanced_transcript: Advanced transcript extraction with filtering, search, and multi-video capabilities
Prompt Tools
transcript_summary: Generate summaries of YouTube video content based on transcripts with customizable options
Resource Tools
youtube://available-youtube-tools: Get a list of all available YouTube toolsyoutube://video/{video_id}: Get detailed information about a specific videoyoutube://channel/{channel_id}: Get information about a specific channelyoutube://transcript/{video_id}?language={language}: Get transcript for a specific video
Development
For local testing, you can use the included client script:
# Example: Search videos
uv run client.py search_videos query="MCP" max_results=5
# Example: Get video details
uv run client.py get_video_details video_id=zRgAEIoZEVQ
# Example: Get channel details
uv run client.py get_channel_details channel_id=UCRpOIr-NJpK9S483ge20Pgw
# Example: Get video comments
uv run client.py get_video_comments video_id=zRgAEIoZEVQ max_results=10 order=time
# Example: Get video transcript
uv run client.py get_video_transcript video_id=zRgAEIoZEVQ language=ko
# Example: Get related videos
uv run client.py get_related_videos video_id=zRgAEIoZEVQ max_results=5
# Example: Get trending videos
uv run client.py get_trending_videos region_code=ko max_results=10
# Example: Advanced transcript extraction
uv run client.py get_video_enhanced_transcript video_ids=zRgAEIoZEVQ language=ko format=timestamped include_metadata=true start_time=100 end_time=200 query=에이전트 case_sensitive=true segment_method=equal segment_count=2
# Example: License
MIT License
Available Tools
8 toolsget_channel_detailsB
Get detailed information about a YouTube channel
| Name | Required | Description | Default |
|---|---|---|---|
| channel_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves 'detailed information' but doesn't specify what details are included (e.g., subscriber count, videos, metadata), whether it's a read-only operation, rate limits, authentication needs, or error handling. This leaves significant gaps in understanding the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with zero wasted words. It's front-loaded with the core purpose and appropriately sized for a simple tool, making it easy to parse quickly without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no nested objects) and the presence of an output schema (which should define return values), the description is minimally adequate. However, with no annotations and low schema coverage, it lacks context on behavior and parameters that could help the agent use it effectively, leaving room for improvement.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage, so the schema provides no semantic context. The description doesn't add any parameter-specific information beyond implying a 'channel_id' is needed. It doesn't explain what a channel ID is, where to find it, or format requirements, resulting in minimal value beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and resource 'detailed information about a YouTube channel', making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'get_video_details' or 'get_video_enhanced_transcript', which also retrieve YouTube content information, so it doesn't fully distinguish its specific scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_video_details' for video-specific data or 'search_videos' for broader searches, leaving the agent without context for tool selection. There's no indication of prerequisites or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_trending_videosB
Get trending videos on YouTube by region
| Name | Required | Description | Default |
|---|---|---|---|
| region_code | No | ||
| max_results | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves trending videos by region but lacks details on permissions, rate limits, data freshness, or response format. This is a significant gap for a tool that likely involves external API calls.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, clearly stating the tool's purpose without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (2 parameters, no annotations, but with an output schema), the description is minimally adequate. The output schema likely covers return values, reducing the burden, but the lack of behavioral details and incomplete parameter semantics leaves room for improvement.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description mentions 'by region,' which aligns with the 'region_code' parameter, adding some context beyond the schema. However, with 0% schema description coverage and 2 parameters, it doesn't fully explain 'max_results' or provide format details for 'region_code,' leaving gaps in parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get trending videos') and resource ('on YouTube by region'), providing a specific purpose. However, it doesn't differentiate this tool from sibling tools like 'search_videos' or 'get_related_videos', which could also retrieve videos in some context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when-not scenarios, prerequisites, or compare it to siblings like 'search_videos' for general queries or 'get_ideo_details' for specific videos, leaving usage ambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_video_commentsC
Get comments for a YouTube video
| Name | Required | Description | Default |
|---|---|---|---|
| video_id | Yes | ||
| max_results | No | ||
| order | No | relevance | |
| include_replies | No | ||
| page_token | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Get comments' but doesn't clarify if this is a read-only operation, whether it requires API keys or permissions, if there are rate limits, or what the output format looks like. The description is too minimal to provide adequate behavioral context for a tool with 5 parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that gets straight to the point with no wasted words. It's appropriately sized for a simple tool name and is front-loaded with the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 5 parameters, 0% schema description coverage, no annotations, but does have an output schema, the description is incomplete. It covers the basic purpose but misses parameter explanations, usage context, and behavioral details. The output schema helps with return values, but the description alone doesn't provide enough context for effective tool selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, meaning none of the 5 parameters have descriptions in the schema. The tool description only mentions 'video_id' implicitly ('for a YouTube video'), leaving the other 4 parameters (max_results, order, include_replies, page_token) completely undocumented. This fails to compensate for the schema's lack of coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('comments for a YouTube video'), making the purpose immediately understandable. It doesn't explicitly distinguish from sibling tools like 'get_video_details' or 'get_video_transcript', but the focus on comments is specific enough to imply differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_video_details' (which might include comments) or 'search_videos' (which might find videos with certain comments). It also lacks context about prerequisites, such as needing a valid video ID or authentication requirements.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_video_detailsB
Get detailed information about a YouTube video
| Name | Required | Description | Default |
|---|---|---|---|
| video_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves 'detailed information' but doesn't specify what that includes (e.g., title, duration, view count), whether it requires authentication, rate limits, or error handling. For a read operation with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves beyond its basic purpose.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the core action and resource, making it easy to parse. Every part of the sentence earns its place by conveying essential information, achieving ideal conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no nested objects) and the presence of an output schema (which should define return values), the description is minimally complete. However, with no annotations and low schema coverage, it lacks details on behavioral aspects like authentication or error cases. For a basic read tool, it's adequate but leaves room for improvement in contextual richness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage, so the description must compensate. It implies the parameter is a 'video_id' for a YouTube video but doesn't clarify format (e.g., YouTube URL vs. ID string), validation, or examples. Since schema coverage is low, the description adds minimal value beyond what's inferred from the schema property name, meeting the baseline for adequate but incomplete parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('detailed information about a YouTube video'), making the purpose unambiguous. It distinguishes this tool from siblings like 'get_video_comments' or 'get_video_transcript' by focusing on general video metadata rather than specific aspects. However, it doesn't explicitly differentiate from 'get_video_enhanced_transcript' which might also provide detailed information, keeping it from a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'get_related_videos', 'get_trending_videos', and 'search_videos', there's no indication that this is for retrieving metadata of a specific known video ID versus browsing or searching. No exclusions or prerequisites are mentioned, leaving usage context implied at best.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_video_enhanced_transcriptC
Advanced transcript extraction tool with filtering, search, and multi-video capabilities. Provides rich transcript data for detailed analysis and processing. Features: 1) Extract transcripts from multiple videos; 2) Filter by time ranges; 3) Search within transcripts; 4) Segment transcripts; 5) Format output in different ways; 6) Include video metadata.
| Name | Required | Description | Default |
|---|---|---|---|
| video_ids | Yes | ||
| language | No | ko | |
| start_time | No | ||
| end_time | No | ||
| query | No | ||
| case_sensitive | No | ||
| segment_method | No | equal | |
| segment_count | No | ||
| format | No | timestamped | |
| include_metadata | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. While it lists features (multi-video extraction, filtering, search, segmentation, formatting, metadata inclusion), it doesn't describe important behavioral aspects: whether this is a read-only operation, potential rate limits, authentication requirements, error conditions, or what happens with invalid parameters. The feature list is helpful but incomplete for behavioral understanding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably concise with two sentences and a numbered feature list. However, the first sentence is somewhat redundant ('Advanced transcript extraction tool' and 'Provides rich transcript data' convey similar ideas). The feature list is helpful but could be more efficiently integrated. Overall, it's adequately structured but not optimally front-loaded with the most critical information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (10 parameters, no annotations, but with output schema), the description provides a reasonable feature overview but has significant gaps. The output schema existence means return values are documented elsewhere, but the description should better explain the tool's scope, limitations, and relationship to sibling tools. For a complex tool with many parameters and no annotations, more behavioral context would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage for 10 parameters, the description provides some parameter context by listing features that map to parameters: 'Extract transcripts from multiple videos' (video_ids), 'Filter by time ranges' (start_time, end_time), 'Search within transcripts' (query, case_sensitive), 'Segment transcripts' (segment_method, segment_count), 'Format output' (format), 'Include video metadata' (include_metadata). However, it doesn't explain the language parameter or provide details about parameter values, constraints, or interactions between parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Advanced transcript extraction tool with filtering, search, and multi-video capabilities' and specifies it 'Provides rich transcript data for detailed analysis and processing.' This is specific about the verb (extract) and resource (transcripts from videos) with additional capabilities. However, it doesn't explicitly distinguish it from its sibling 'get_video_transcript' - the 'enhanced' aspect is implied but not directly contrasted.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. While it lists features like filtering, search, and multi-video capabilities, it doesn't indicate when these advanced features are needed versus the simpler 'get_video_transcript' sibling tool. There's no mention of prerequisites, performance considerations, or specific use cases that would help an agent choose between available transcript tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_video_transcriptB
Get transcript/captions for a YouTube video
| Name | Required | Description | Default |
|---|---|---|---|
| video_id | Yes | ||
| language | No | ko |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but lacks details on permissions, rate limits, error handling, or response format. For a tool with an output schema, some context is implied, but key behavioral traits are missing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It is front-loaded and directly states the tool's purpose, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (2 parameters, no annotations, but with an output schema), the description is minimally adequate. The output schema reduces the need to explain return values, but the lack of behavioral context and usage guidelines leaves gaps in completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description mentions 'transcript/captions' and 'YouTube video', which loosely relates to the 'video_id' parameter, but adds minimal semantic value beyond the schema. With 0% schema description coverage, it partially compensates by hinting at the resource, but does not explain parameter roles or the 'language' parameter's purpose.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('transcript/captions for a YouTube video'), making the tool's function immediately understandable. However, it does not distinguish this tool from its sibling 'get_video_enhanced_transcript', which could cause confusion about when to use each one.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as 'get_video_enhanced_transcript' or other sibling tools. There is no mention of prerequisites, context, or exclusions, leaving the agent without usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_videosC
Search for YouTube videos with advanced filtering options
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| max_results | No | ||
| channel_id | No | ||
| order | No | ||
| video_duration | No | ||
| published_after | No | ||
| published_before | No | ||
| video_caption | No | ||
| video_definition | No | ||
| region_code | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool searches with filtering but doesn't mention key traits like whether it's read-only, has rate limits, requires authentication, returns paginated results, or what the output format entails. For a search tool with 10 parameters and no annotations, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence: 'Search for YouTube videos with advanced filtering options.' It's front-loaded with the core purpose and avoids unnecessary words, making it highly concise and well-structured for quick understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (10 parameters, no annotations, but has an output schema), the description is incomplete. It covers the basic purpose but lacks usage guidelines, behavioral details, and parameter explanations. The presence of an output schema means return values are documented elsewhere, but for a tool with many parameters and no annotations, more context is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning parameter titles (e.g., 'Query', 'Max Results') lack detailed descriptions in the schema. The description adds minimal value by hinting at 'advanced filtering options' but doesn't explain what parameters like 'order', 'video_duration', or 'region_code' mean or how to use them. It fails to compensate for the low schema coverage, leaving most parameters semantically unclear.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Search for YouTube videos with advanced filtering options.' It specifies the verb ('search'), resource ('YouTube videos'), and scope ('advanced filtering options'), which is specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'get_related_videos' or 'get_trending_videos,' which might also involve video retrieval, so it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions 'advanced filtering options' but doesn't specify scenarios where this is preferred over siblings like 'get_trending_videos' (for trending content) or 'get_related_videos' (for context-based retrieval). Without such context, the agent lacks clear usage rules.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
8 tool updates
v1.0.0- Changed
get_channel_details1 field changed- changed
Output schema / (root)Previous value: -nullNew value: +{ + "properties": { + "result": { + "additionalProperties": true, + "title": "Result", + "type": "object" + } + }, + "required": [ + "result" + ], + "title": "get_channel_detailsOutput", + "type": "object" +}
- Changed
get_related_videos1 field changed- changed
Output schema / (root)Previous value: -nullNew value: +{ + "properties": { + "result": { + "additionalProperties": true, + "title": "Result", + "type": "object" + } + }, + "required": [ + "result" + ], + "title": "get_related_videosOutput", + "type": "object" +}
- Changed
get_trending_videos1 field changed- changed
Output schema / (root)Previous value: -nullNew value: +{ + "properties": { + "result": { + "additionalProperties": true, + "title": "Result", + "type": "object" + } + }, + "required": [ + "result" + ], + "title": "get_trending_videosOutput", + "type": "object" +}
- Changed
get_video_comments1 field changed- changed
Output schema / (root)Previous value: -nullNew value: +{ + "properties": { + "result": { + "additionalProperties": true, + "title": "Result", + "type": "object" + } + }, + "required": [ + "result" + ], + "title": "get_video_commentsOutput", + "type": "object" +}
- Changed
get_video_details1 field changed- changed
Output schema / (root)Previous value: -nullNew value: +{ + "properties": { + "result": { + "additionalProperties": true, + "title": "Result", + "type": "object" + } + }, + "required": [ + "result" + ], + "title": "get_video_detailsOutput", + "type": "object" +}
- Changed
get_video_enhanced_transcript1 field changed- changed
Output schema / (root)Previous value: -nullNew value: +{ + "properties": { + "result": { + "additionalProperties": true, + "title": "Result", + "type": "object" + } + }, + "required": [ + "result" + ], + "title": "get_video_enhanced_transcriptOutput", + "type": "object" +}
- Changed
get_video_transcript1 field changed- changed
Output schema / (root)Previous value: -nullNew value: +{ + "properties": { + "result": { + "additionalProperties": true, + "title": "Result", + "type": "object" + } + }, + "required": [ + "result" + ], + "title": "get_video_transcriptOutput", + "type": "object" +}
- Changed
search_videos1 field changed- changed
Output schema / (root)Previous value: -nullNew value: +{ + "properties": { + "result": { + "additionalProperties": true, + "title": "Result", + "type": "object" + } + }, + "required": [ + "result" + ], + "title": "search_videosOutput", + "type": "object" +}
8 tool updates
- First observed
get_channel_details - First observed
get_related_videos - First observed
get_trending_videos - First observed
get_video_comments - First observed
get_video_details - First observed
get_video_enhanced_transcript - First observed
get_video_transcript - First observed
search_videos
TDQS
Most tools have distinct purposes, but there is notable overlap between get_video_transcript and get_video_enhanced_transcript, which could cause confusion as both handle transcripts with the enhanced version being a superset. Other tools like get_video_details and get_channel_details are clearly differentiated, but the transcript duplication weakens clarity.
All tool names follow a consistent snake_case pattern with a verb-noun structure (e.g., get_channel_details, search_videos). The naming is predictable and uniform across all eight tools, making it easy for agents to understand and use them without confusion.
With 8 tools, the count is well within the typical 3-15 range for a focused domain like YouTube data retrieval. It feels slightly thin for comprehensive coverage but reasonable for core functionalities such as fetching videos, channels, comments, and transcripts.
The toolset covers key read operations like getting details, searching, and fetching comments/transcripts, but lacks obvious write or management capabilities (e.g., upload, update, delete) that might be expected in a full YouTube toolbox. This creates notable gaps for agents needing to perform more than retrieval tasks.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
An MCP server that integrates with Discord to provide AI-powered features.
An MCP server that gives any LLM or agent clean YouTube transcripts on demand: a single video, a whole channel, or a playlist, plus AI cleanup of auto-generated captions. API-key auth, credit-based, same backend as the public v1 API. Get a free API key with 25 free credits at youtubetranscriptdownload.com/account.
Driflyte MCP server which lets AI assistants query topic-specific knowledge from web and GitHub.
MCP server for Google Veo AI video generation
Related MCP Servers
- AlicenseAqualityCmaintenanceAn MCP server for intelligent YouTube video analysis that provides token-optimized summaries, sentiment analysis, and entity extraction from transcripts. It enables AI assistants to perform video reporting, channel monitoring, and comprehensive YouTube searches through structured data tools.1051Apache 2.0
- AlicenseAqualityDmaintenanceMCP server that provides YouTube video data to AI agents, supporting search, metadata, comments, and transcripts without an API key.527MIT
- AlicenseAqualityDmaintenanceMCP server that lets AI agents search YouTube and fetch transcripts.23MIT
- FlicenseNot gradedqualityBmaintenanceMCP server for YouTube that provides tools to fetch video metadata and transcripts, enabling natural language queries about YouTube videos.2-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/jikime/py-mcp-youtube-toolbox'
If you have feedback or need assistance with the MCP directory API, please join our Discord server