YouTube Knowledge MCP
Provides AI-enhanced video processing features such as content analysis, learning path creation, knowledge graph generation, and transcript processing using OpenAI's language models
Offers optional caching functionality to reduce API costs and improve performance by storing frequently accessed YouTube data and AI analysis results
Provides comprehensive YouTube integration with tools for searching videos, fetching video details and transcripts, analyzing trending content, searching channels, and AI-powered features like content analysis, learning path generation, and knowledge graph creation
Click on "Deploy 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 Knowledge MCPsearch for beginner Python tutorials from the last year"
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.
YouTube Knowledge MCP
Production-ready Model Context Protocol (MCP) server that turns YouTube into a queryable knowledge source. Search, fetch details, analyze transcripts/comments, and power AI workflows with optional LLMs. Built for Claude Desktop and other MCP clients.
Why this is special
Fast + quota-aware YouTube API access with caching
Batteries-included tools for search, details, trending, channels
Optional AI superpowers (OpenAI/Anthropic) for summaries, topics, chapters, learning paths, comment intents, and knowledge graphs
Zero noise: minimal config, clear logs, safe defaults
Requirements
Node.js 18+
YouTube Data API v3 key
Optional: OpenAI and/or Anthropic API keys for AI tools
Install
npm installConfigure environment
Create .env (or set variables in your MCP client config). You can start from the example:
cp env.example .envThen set values in .env:
# Required
YOUTUBE_API_KEY=your_youtube_api_key
# Optional AI providers (enables AI tools: analyze_video_content, generate_learning_path, analyze_comment_intents, simplify_video_transcript, generate_video_chapters, generate_knowledge_graph)
OPENAI_API_KEY=your_openai_api_key
ANTHROPIC_API_KEY=your_anthropic_api_key
# Optional tuning
LOG_LEVEL=info
MAX_DAILY_QUOTA=8000
REDIS_URL= # e.g. redis://localhost:6379
REDIS_HOST=
REDIS_PORT=
REDIS_PASSWORD=An env.example with placeholders is provided. Do not commit your .env.
Build and run
# Development (watch)
npm run dev
# Production
npm run build
npm startConnect to Claude Desktop (example)
Add to your Claude Desktop configuration with absolute paths:
{
"mcpServers": {
"youtube-knowledge": {
"command": "node",
"args": ["/absolute/path/to/youtube-knowledge-mcp/build/index.js"],
"env": {
"YOUTUBE_API_KEY": "your_youtube_api_key",
"OPENAI_API_KEY": "optional_openai",
"ANTHROPIC_API_KEY": "optional_anthropic",
"LOG_LEVEL": "info"
}
}
}
}Restart Claude Desktop after editing the config.
Available tools
youtube_search— Search videos with filtersget_video_details— Video metadata, transcript (best-effort), commentsget_trending_videos— Most popular by region/categorysearch_channels— Channel search with optional statsanalyze_video_content— AI topics/sentiment/questions/summary/keywordsgenerate_learning_path— AI learning path for a topicanalyze_comment_intents— Classify viewer intentssimplify_video_transcript— ELI5-style simplificationgenerate_video_chapters— AI chapters with timestampsgenerate_knowledge_graph— Cross-video concept graph
Note: AI tools are available only if an AI provider key is configured.
Quotas and safety
Enforces daily quota (default 8000 units) and cost-aware AI usage
Logs to stderr (does not break MCP stdio)
Caching reduces API and token spend; optional Redis supported
Troubleshooting
Missing key: ensure
YOUTUBE_API_KEYis setQuota exceeded: lower usage, enable caching, or raise
MAX_DAILY_QUOTAClaude cannot connect: verify absolute path to
build/index.jsand restart
License
MIT By Efi Kuta
Available Tools
10 toolsanalyze_comment_intentsC
Analyze YouTube comments to extract user intents and actionable insights
| Name | Required | Description | Default |
|---|---|---|---|
| videoId | Yes | YouTube video ID to analyze comments from | |
| maxComments | No | Maximum number of comments to analyze | |
| intentCategories | No | Custom intent categories to focus on (optional) |
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 mentions 'analyze' and 'extract' but does not specify whether this is a read-only operation, requires authentication, has rate limits, or details the output format (e.g., structured insights vs. raw data). For a tool with no annotations, this lack of behavioral context is a significant gap.
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 is front-loaded with the core action and outcome, making it easy to parse and understand quickly, which is ideal for 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 complexity of analyzing comments for intents and insights, the description is incomplete. No annotations are provided to clarify behavioral traits, and there is no output schema to explain return values. The description alone does not compensate for these gaps, making it inadequate for a tool that likely produces structured insights from unstructured data.
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 100%, so the input schema fully documents the parameters (videoId, maxComments, intentCategories). The description adds no additional semantic meaning beyond what the schema provides (e.g., it does not explain what 'intentCategories' might include or how analysis is performed), resulting in a baseline score of 3 as the schema does the heavy lifting.
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 ('analyze YouTube comments') and the outcome ('extract user intents and actionable insights'), which is specific and informative. However, it does not explicitly differentiate this tool from sibling tools like 'analyze_video_content' or 'simplify_video_transcript', which might also involve comment or content analysis, leaving some ambiguity about its unique role.
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 does not mention scenarios where it is preferred over sibling tools (e.g., 'analyze_video_content' for broader analysis or 'simplify_video_transcript' for transcript processing), nor does it specify prerequisites or exclusions, leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
analyze_video_contentC
Get AI-powered analysis and insights from video content
| Name | Required | Description | Default |
|---|---|---|---|
| videoId | Yes | YouTube video ID to analyze | |
| analysisType | No | Types of analysis to perform | |
| includeComments | No | Include comments in the analysis |
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 mentions 'AI-powered analysis' but lacks details on permissions, rate limits, processing time, or output format. For a tool with three parameters and no output schema, this is a significant gap in transparency about how the tool behaves and what to expect.
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 front-loads the core purpose without unnecessary words. It avoids redundancy and wastes no space, making it easy for an agent to parse quickly while conveying the essential function.
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 complexity (AI analysis with multiple parameter options), lack of annotations, and no output schema, the description is insufficiently complete. It doesn't address behavioral aspects like error handling, output structure, or usage constraints, leaving critical gaps for the agent to understand the tool's full context and operation.
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 100%, so the input schema fully documents parameters like 'videoId' and 'analysisType.' The description adds no additional semantic context beyond implying general analysis, such as explaining what 'insights' entail or how parameters interact. This meets the baseline for high schema coverage but doesn't enhance 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 tool's purpose as 'Get AI-powered analysis and insights from video content,' specifying the action ('analysis and insights'), resource ('video content'), and method ('AI-powered'). However, it doesn't distinguish this from sibling tools like 'simplify_video_transcript' or 'generate_video_chapters,' which also process video content, leaving some ambiguity about scope 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. It doesn't mention sibling tools like 'get_video_details' for basic metadata or 'simplify_video_transcript' for text processing, nor does it specify prerequisites such as video accessibility or analysis scope. This leaves the agent without context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_knowledge_graphC
Create cross-video knowledge graphs showing concept relationships
| Name | Required | Description | Default |
|---|---|---|---|
| videoIds | Yes | YouTube video IDs to create knowledge graph from | |
| graphDepth | No | Depth of concept extraction and analysis | medium |
| focusTopics | No | Specific topics to focus on (optional) | |
| includeTranscripts | No | Include transcript content in analysis |
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 'creates' knowledge graphs, implying a generative/mutation operation, but fails to describe what 'create' entails—such as whether it returns a visual graph, data structure, or summary; potential rate limits; or any side effects like storing results. 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, efficient sentence that front-loads the core purpose without any wasted words. It directly states what the tool does, making it easy to parse and understand quickly, which is ideal for 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 complexity of creating knowledge graphs from multiple videos, the lack of annotations, and no output schema, the description is insufficient. It doesn't explain the output format (e.g., graph data, visualization), error conditions, or behavioral nuances like processing time or resource usage, leaving the agent poorly equipped to use this tool effectively.
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 100% description coverage, clearly documenting all four parameters. The description adds no additional meaning beyond the schema, such as explaining how 'graphDepth' affects output or what 'focusTopics' prioritizes. Since the schema does the heavy lifting, a baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.
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 ('create') and resource ('cross-video knowledge graphs showing concept relationships'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'analyze_video_content' or 'generate_learning_path', which might also involve video analysis and content generation.
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 prerequisites, such as needing video IDs, or compare it to siblings like 'analyze_video_content' for simpler analysis or 'generate_learning_path' for structured learning content, leaving the agent with no context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_learning_pathC
Generate AI-powered learning paths from YouTube content with difficulty assessment
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Topic or subject for the learning path | |
| targetLevel | No | Target skill level for the learning path | beginner |
| maxVideos | No | Maximum number of videos to include | |
| includeQuizzes | No | Whether to generate quiz questions |
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. It mentions 'AI-powered' and 'difficulty assessment', but doesn't disclose key behavioral traits such as how the AI selects videos, what the output format looks like, whether it requires internet access, potential rate limits, or error handling. For a tool with no annotations, this leaves significant gaps in understanding its operation.
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 front-loads the core functionality ('Generate AI-powered learning paths') and includes key features ('from YouTube content with difficulty assessment'). There is no wasted text, making it highly concise and well-structured for quick comprehension.
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 of generating learning paths with AI and no output schema, the description is incomplete. It lacks details on the output format, how videos are selected and ordered, what 'difficulty assessment' entails, and any limitations or dependencies. With no annotations and missing output information, it doesn't provide enough context for 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 100%, so the schema fully documents all parameters. The description adds no specific parameter semantics beyond implying that 'query' relates to the learning topic and 'targetLevel' influences difficulty assessment. This meets the baseline of 3 since the schema handles the heavy lifting, but the description doesn't enhance 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 ('Generate AI-powered learning paths') and resource ('from YouTube content'), with the additional feature of 'difficulty assessment'. It distinguishes itself from siblings like 'generate_video_chapters' or 'simplify_video_transcript' by focusing on structured learning paths rather than content analysis or modification. However, it doesn't explicitly differentiate from 'generate_knowledge_graph', which might also organize content.
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 prerequisites, such as needing YouTube content availability, or compare it to siblings like 'generate_knowledge_graph' for knowledge organization or 'search_channels' for content discovery. Usage is implied by the purpose but lacks explicit context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_video_chaptersB
Generate AI-powered video chapters with timestamps and descriptions
| Name | Required | Description | Default |
|---|---|---|---|
| videoId | Yes | YouTube video ID to generate chapters for | |
| maxChapters | No | Maximum number of chapters to generate | |
| minChapterLength | No | Minimum chapter length in seconds | |
| includeDescriptions | No | Include detailed chapter descriptions |
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 mentions 'AI-powered' but doesn't detail how the AI works, potential limitations (e.g., accuracy, processing time), or output format (e.g., JSON structure). For a tool with no annotation coverage, this leaves significant gaps in understanding its 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, efficient sentence that front-loads the core purpose without unnecessary words. It directly states what the tool does without redundancy or fluff, 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 no annotations and no output schema, the description is moderately complete for a tool with 4 parameters and 100% schema coverage. It covers the basic purpose but lacks details on behavioral traits (e.g., AI model used, error handling) and output format, which are important for an AI agent to use it effectively.
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 100%, so the schema already documents all parameters thoroughly. The description adds no additional meaning beyond what's in the schema (e.g., it doesn't explain how 'maxChapters' interacts with 'minChapterLength' or typical use cases for parameters). With high schema coverage, the baseline score of 3 is appropriate.
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: 'Generate AI-powered video chapters with timestamps and descriptions.' It specifies the action (generate), the resource (video chapters), and key attributes (AI-powered, with timestamps and descriptions). However, it doesn't explicitly differentiate from sibling tools like 'analyze_video_content' or 'simplify_video_transcript', which might have overlapping functionality.
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 prerequisites (e.g., video accessibility), exclusions (e.g., unsupported video types), or comparisons to sibling tools like 'analyze_video_content' or 'get_video_details'. Usage is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_trending_videosC
Discover trending videos in different categories and regions
| Name | Required | Description | Default |
|---|---|---|---|
| category | No | Category ID or name (e.g., "Technology", "Education") | |
| region | No | Region code for trending videos | US |
| maxResults | No | Maximum number of trending videos to return |
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 what the tool does but doesn't mention critical aspects like whether this is a read-only operation, rate limits, authentication needs, or what the return format looks like. For a tool with 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 that directly states the tool's purpose with zero wasted words. It's appropriately sized and front-loaded, making it easy for an agent 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 lack of annotations and output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., video list format, metadata), behavioral traits, or usage context relative to siblings. For a tool with no structured output information, the description should provide more 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 input schema has 100% description coverage, providing clear documentation for all three parameters. The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline of 3 without compensating or enhancing the schema's information.
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 with the verb 'discover' and resource 'trending videos', and specifies scope with 'different categories and regions'. However, it doesn't explicitly distinguish this from sibling tools like 'youtube_search' or 'get_video_details', which prevents a score of 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 like 'youtube_search' or 'get_video_details'. It mentions categories and regions but doesn't specify use cases, prerequisites, or exclusions, leaving the agent with minimal context for tool selection.
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 comprehensive information about a specific YouTube video
| Name | Required | Description | Default |
|---|---|---|---|
| videoId | Yes | YouTube video ID | |
| includeTranscript | No | Whether to include video transcript | |
| includeComments | No | Whether to include video comments | |
| maxComments | No | Maximum number of comments to retrieve | |
| commentsOrder | No | Sort order for comments | relevance |
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 mentions 'comprehensive information' but doesn't specify what that includes beyond the parameters (e.g., metadata like title, duration, or statistics), whether it's a read-only operation, potential rate limits, authentication needs, or error handling. For a tool with 5 parameters and no annotation coverage, this leaves significant behavioral gaps.
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 front-loads the core purpose ('Get comprehensive information about a specific YouTube video'). There is no wasted verbiage, repetition, or unnecessary details, 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 (5 parameters, no annotations, no output schema), the description is minimally adequate. It states the purpose clearly but lacks behavioral context, usage guidelines, and details on return values. With no output schema, the description doesn't explain what 'comprehensive information' includes, leaving gaps in completeness. It meets a basic threshold but doesn't fully address the tool's scope.
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 100% description coverage, providing clear details for all 5 parameters (e.g., videoId, includeTranscript, maxComments range). The description adds no additional parameter semantics beyond implying 'comprehensive information,' which aligns with the schema but doesn't enhance it. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't detract.
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 with a specific verb ('Get') and resource ('comprehensive information about a specific YouTube video'). It distinguishes from siblings like 'get_trending_videos' (which lists videos) and 'analyze_video_content' (which analyzes rather than retrieves information). However, it doesn't explicitly differentiate from all siblings like 'simplify_video_transcript' or 'generate_video_chapters', which prevents 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. It doesn't mention prerequisites (e.g., needing a valid video ID), exclusions (e.g., not for batch processing), or comparisons to siblings like 'youtube_search' (for finding videos) or 'analyze_video_content' (for deeper analysis). Usage is implied by the name and purpose but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_channelsC
Find and analyze YouTube channels
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query for YouTube channels | |
| maxResults | No | Maximum number of channels to return | |
| includeStats | No | Whether to include channel statistics | |
| order | No | Sort order for channels | relevance |
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. 'Find and analyze' implies a read-only operation, but it doesn't specify whether this requires authentication, has rate limits, what 'analyze' entails (e.g., statistical analysis vs. content analysis), or the format of returned data. This leaves significant gaps for a tool with 4 parameters and no output schema.
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 extremely concise at just 5 words ('Find and analyze YouTube channels'), with zero wasted words. It's front-loaded with the core purpose, making it efficient 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 (4 parameters, no output schema, no annotations), the description is insufficient. It doesn't explain what 'analyze' means in practice, how results are returned, or any behavioral constraints. For a search/analysis tool with multiple parameters, 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 100%, meaning all parameters are documented in the schema itself. The description doesn't add any parameter-specific information beyond what's in the schema (e.g., it doesn't explain how the 'query' parameter differs from general YouTube search or what 'analyze' corresponds to in the parameters). Baseline 3 is appropriate when the schema does the heavy lifting.
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 'Find and analyze YouTube channels' clearly states the verb ('find and analyze') and resource ('YouTube channels'), making the purpose immediately understandable. However, it doesn't distinguish this tool from sibling tools like 'youtube_search' or 'get_trending_videos', which likely involve similar YouTube content discovery.
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 sibling tools like 'youtube_search' (which might search for videos rather than channels) and 'get_trending_videos', there's clear potential for confusion, but the description offers no explicit when-to-use or when-not-to-use instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
simplify_video_transcriptB
Create age-appropriate simplified versions of video transcripts (ELI5 mode)
| Name | Required | Description | Default |
|---|---|---|---|
| videoId | Yes | YouTube video ID to simplify | |
| targetAge | No | Target age for simplification | |
| outputFormat | No | Preferred output format | paragraph |
| includeDefinitions | No | Include definitions for key terms |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions the transformation behavior ('simplified versions'), it doesn't disclose important traits like whether this is a read-only operation (likely not, since it creates new content), potential rate limits, authentication requirements, or what the output looks like. The description is minimal and lacks operational context needed for a tool that presumably generates new content.
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 communicates the core purpose without unnecessary words. It's front-loaded with the main action and resource, and the parenthetical 'ELI5 mode' adds useful context without expanding the sentence structure. Every element earns its place.
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?
For a content-generation tool with 4 parameters and no annotations or output schema, the description is insufficient. It doesn't explain what the output looks like, whether the simplification preserves meaning, how it handles different video lengths, or any quality considerations. The description alone doesn't provide enough context for an agent to understand the full scope and limitations of this tool.
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 100%, so all parameters are well-documented in the schema itself. The description adds no additional parameter semantics beyond what's already in the schema descriptions. It mentions 'age-appropriate' which relates to the targetAge parameter, but this is already covered in the schema. With complete schema coverage, the baseline score of 3 is appropriate.
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 specific action ('Create age-appropriate simplified versions') and resource ('video transcripts'), with additional context about the simplification approach ('ELI5 mode'). It distinguishes from sibling tools like analyze_video_content or generate_video_chapters by focusing specifically on transcript simplification rather than analysis, chapter generation, or other video-related operations.
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 implies usage context through 'age-appropriate' and 'ELI5 mode', suggesting this tool is for educational or accessibility purposes. However, it doesn't explicitly state when to use this tool versus alternatives like analyze_video_content (which might provide different insights) or when not to use it (e.g., for verbatim transcripts). No specific alternatives or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
youtube_searchC
Search for videos on YouTube with advanced filtering options
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query for YouTube videos | |
| maxResults | No | Maximum number of results (1-50) | |
| publishedAfter | No | Filter videos published after this date (ISO 8601 format) | |
| publishedBefore | No | Filter videos published before this date (ISO 8601 format) | |
| order | No | Sort order for results | relevance |
| videoDuration | No | Filter by video duration | any |
| videoDefinition | No | Filter by video quality | any |
| regionCode | No | Region code for localized results (e.g., "US", "GB") |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'Search' implies a read operation, it doesn't address authentication requirements, rate limits, pagination behavior, error handling, or what the response format looks like. For a search tool with 8 parameters and no output schema, this leaves significant behavioral gaps.
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 communicates the core purpose without waste. It's appropriately sized for a search tool and front-loads the essential information. Every word earns its place.
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?
For a search tool with 8 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address what the search returns (video metadata, URLs, thumbnails?), authentication needs, rate limits, or error conditions. The agent lacks sufficient context to use this tool effectively beyond basic parameter passing.
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 100%, so the schema already documents all 8 parameters thoroughly. The description adds minimal value beyond stating 'advanced filtering options' - it doesn't explain parameter relationships, provide usage examples, or add semantic context not already in the schema descriptions. Baseline 3 is appropriate when schema does the heavy lifting.
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 'Search for videos on YouTube with advanced filtering options' - a specific verb ('Search') and resource ('videos on YouTube') with scope ('advanced filtering options'). It doesn't explicitly differentiate from sibling tools like 'search_channels' or 'get_trending_videos', but the focus on video search is clear.
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 'search_channels' (for channel search) or 'get_trending_videos' (for trending content). There's no mention of prerequisites, use cases, or when-not-to-use scenarios. The agent must infer usage from tool names alone.
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.
10 tool updates
- First observed
analyze_comment_intents - First observed
analyze_video_content - First observed
generate_knowledge_graph - First observed
generate_learning_path - First observed
generate_video_chapters - First observed
get_trending_videos - First observed
get_video_details - First observed
search_channels - First observed
simplify_video_transcript - First observed
youtube_search
TDQS
Scored across 10 tools
Each tool has a clearly distinct purpose targeting specific YouTube operations: content analysis, search, metadata retrieval, and content transformation. There is no overlap in functionality; for example, analyze_video_content focuses on video insights while simplify_video_transcript handles transcript simplification, making misselection unlikely.
The naming follows a consistent verb_noun pattern with snake_case throughout, such as analyze_comment_intents and generate_video_chapters. The only minor deviation is youtube_search, which uses the platform name as a prefix instead of a verb, but it still fits the overall readable convention.
With 10 tools, the count is well-scoped for a YouTube knowledge server, covering a broad range of functionalities from search and analysis to content generation. Each tool earns its place by addressing distinct aspects of video and channel processing without feeling excessive or insufficient.
The tool set provides comprehensive coverage for YouTube knowledge extraction, including search, analysis, metadata retrieval, and content transformation. Minor gaps exist, such as the lack of tools for managing playlists or user interactions, but core workflows for learning and insights are well-supported.
Maintenance
Related MCP Connectors
YouTube transcripts, search, channel/playlist listings and upload tracking for AI agents.
YouTube transcripts, search, channels, playlists and bulk transcript jobs for AI agents. 14 tools.
YouTube data for AI agents: channels, videos, transcripts, comments, search. Video research.
Transcribe YouTube via Whisper. Summaries, chapters, semantic-search across your corpus.
Related MCP Servers
- AlicenseBqualityCmaintenanceEnables extraction of transcripts, keyword-based video search with metadata retrieval, and channel information discovery from YouTube videos through natural language interaction.34MIT
- AlicenseBqualityDmaintenanceEnables AI assistants to search YouTube videos using the official YouTube Data API v3, extract full video transcripts in multiple languages, and store/retrieve video summaries using a local database.4MIT
- AlicenseAqualityCmaintenanceProvides production-grade tools for YouTube channel resolution, video metadata extraction, transcripts, and playlist management. It features a quota-aware, AI-friendly design that supports structured searching and listing of public YouTube data.72MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI assistants to search videos, read channels, browse playlists, fetch comments, and get transcripts from YouTube using the YouTube Data API v3 and InnerTube API for captions.2GPL 3.0