TMDB MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.1
Disambiguation4/5
Most tools have distinct purposes targeting specific resources (movies, TV shows, people) with clear action differentiation. However, discover_movies and search_movies have potential overlap in movie-finding functionality, though their descriptions clarify discover uses advanced filters while search uses title matching.
Naming Consistency5/5
All tools follow a consistent verb_noun pattern with clear action prefixes (discover_, get_, search_) and specific resource suffixes (_movies, _tv_shows, _person, _people). The naming is perfectly predictable and systematic throughout the set.
Tool Count5/5
13 tools is well-scoped for a movie/TV database server, providing comprehensive coverage without bloat. The count aligns with the domain's natural divisions between movies, TV shows, and people, with appropriate operations for each.
Completeness5/5
The toolset provides complete coverage for a TMDB-like domain with discovery, search, detailed retrieval, credits, recommendations, and trending operations for both movies and TV shows, plus person/people functionality. No obvious gaps exist for typical agent workflows.
Average 3.4/5 across 13 of 13 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 2 of 2 community issues answered or closed in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
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 that the tool 'Returns what's currently popular on TMDB based on user activity,' which adds some context about the data source and criteria. However, it lacks details on rate limits, authentication needs, response format, or pagination behavior (beyond the 'page' parameter in the schema). For a tool with no annotations, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, consisting of two sentences that directly state the tool's purpose and return behavior. There is no unnecessary information, and each sentence serves a clear purpose. However, it could be slightly improved by integrating usage guidance more explicitly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is adequate but incomplete. It covers the basic purpose and data source but lacks details on behavioral traits, output format, and usage guidelines. Without an output schema, the description should ideally explain return values, which it does not. This results in a minimal viable level of completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 three parameters (media_type, time_window, page). The description does not add any parameter-specific semantics beyond what the schema already covers. According to the rules, with high schema coverage (>80%), the baseline score is 3, as the description does not need to compensate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get daily or weekly trending movies, TV shows, or people.' It specifies the verb ('Get') and resource ('trending movies, TV shows, or people'), but does not explicitly differentiate it from sibling tools like 'discover_movies' or 'search_movies' beyond mentioning it's based on 'what's currently popular on TMDB based on user activity.' This is clear but lacks explicit sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides minimal usage guidance. It mentions 'daily or weekly' and 'currently popular on TMDB based on user activity,' which implies context, but does not specify when to use this tool versus alternatives like 'discover_movies' or 'search_movies.' No explicit when/when-not scenarios or alternative recommendations are included, leaving gaps in guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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. It mentions the return format ('list of TV shows with basic information') which is helpful, but doesn't cover important aspects like rate limits, authentication requirements, error conditions, or whether this is a read-only operation. For a search tool with zero annotation coverage, this leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with two sentences that efficiently convey the core functionality. The first sentence states the purpose, the second describes the return format. There's no wasted text, though it could be slightly more structured by separating concerns more clearly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with 2 parameters and 100% schema coverage but no output schema, the description provides basic context about what the tool does and returns. However, it lacks important contextual information about limitations (result count, sorting), error handling, and differentiation from sibling tools. The absence of an output schema means the description should ideally explain the return structure more thoroughly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents both parameters. The description doesn't add any parameter semantics beyond what's in the schema - it mentions 'search query' but doesn't elaborate on query syntax, matching behavior, or result ordering. The 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.
Purpose4/5
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 TV shows by name' with a specific verb ('search') and resource ('TV shows'). It distinguishes from siblings like 'search_movies' by specifying the resource type, but doesn't explicitly differentiate from 'discover_tv_shows' which might have different functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 to choose 'search_tv_shows' over 'discover_tv_shows' or 'get_trending', nor does it provide any context about prerequisites or limitations. The agent must infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 the return format ('list of movies with basic information') but lacks details on rate limits, authentication needs, error handling, or pagination behavior beyond the schema's 'page' parameter. This is inadequate for a search tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded: the first sentence states the purpose, and the second explains the return value. There is no wasted language, and every sentence adds value, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (search with pagination), no annotations, and no output schema, the description is minimally adequate. It covers the basic purpose and return format but lacks details on behavioral traits and usage context, leaving gaps that could hinder effective tool selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 both parameters ('query' and 'page') fully. The description adds no additional meaning beyond implying the search is title-based, which is already covered in the schema's 'query' description. Baseline 3 is appropriate as the schema handles parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 movies by title' specifies the verb (search) and resource (movies), and 'Returns a list of movies matching the search query' indicates the outcome. However, it does not explicitly differentiate from siblings like 'search_tv_shows' or 'search_people', which reduces the score from 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.
Usage Guidelines2/5
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 siblings like 'discover_movies' or 'get_trending', nor does it specify any context, prerequisites, or exclusions for usage, leaving the agent to infer based on tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 'advanced filters' and provides examples, it doesn't describe important behavioral aspects like pagination behavior (implied by the 'page' parameter but not explained), rate limits, authentication requirements, or what happens when no results match filters. This leaves significant gaps in understanding how the tool behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured in two sentences: the first states the core purpose, the second provides concrete examples. Every sentence adds value, and it's appropriately front-loaded with the main functionality. It could be slightly more concise by removing 'Perfect for' phrasing, but overall it's well-structured without wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 7-parameter discovery tool with no annotations and no output schema, the description provides adequate basic context about what the tool does and example use cases. However, it doesn't address important contextual aspects like result format, pagination details, error conditions, or how it differs from sibling discovery tools. Given the tool's complexity and lack of structured metadata, the description should provide more complete operational context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description mentions filter categories (genre, language, year, rating, sorting) that align with the 7 parameters in the schema. Since schema description coverage is 100%, the baseline is 3. The description adds minimal value beyond the schema by providing example use cases, but doesn't explain parameter interactions or provide additional semantic context beyond what's already documented in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 'Discover TV shows with advanced filters' and provides specific examples of criteria, which gives a concrete understanding of its function. However, it doesn't explicitly differentiate from sibling tools like 'search_tv_shows' or 'get_tv_recommendations', which likely offer different discovery mechanisms.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through examples ('Perfect for finding shows that match specific criteria'), suggesting this tool is for filtered discovery rather than general browsing. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'search_tv_shows' or 'get_tv_recommendations', leaving some ambiguity about tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It mentions the return content (biography, birth info, etc.) but doesn't disclose behavioral traits like rate limits, authentication needs, error conditions, or data freshness. For a read operation with zero annotation coverage, this leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized (two sentences) and front-loaded with the core purpose. Every sentence adds value: the first states the action and resource, the second lists return fields. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 1 parameter with full schema coverage and no output schema, the description is moderately complete. It covers the purpose and return content but lacks behavioral context (e.g., rate limits, errors) and doesn't fully compensate for missing annotations. Adequate but with clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 the single parameter (person_id as TMDB ID). The description doesn't add any parameter-specific details beyond what the schema provides, such as where to obtain IDs or format constraints. Baseline 3 is appropriate when schema does the work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get detailed biographical information about a person' with specific resource types (actor, director, crew member). It distinguishes from siblings like search_people (which likely searches) and get_movie/tv_credits (which focus on credits rather than biography). However, it doesn't explicitly contrast with all siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when biographical details are needed, but doesn't explicitly state when to use this vs. alternatives like search_people (for finding IDs) or get_movie/tv_credits (for filmography). No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It states this is a read operation ('Get') and lists return fields (budget, revenue, etc.), which adds some behavioral context. However, it lacks details on error handling, rate limits, authentication needs, or response format specifics, leaving gaps for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: the first states the purpose and parameter, the second lists return details. It's front-loaded with essential info and avoids redundancy. Every sentence adds value, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
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 partially compensates by listing return fields. However, for a tool with 1 parameter and 100% schema coverage, it lacks details on output structure, error cases, or integration context. It's adequate but has clear gaps in completeness for a read operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'movie_id' documented as 'TMDB movie ID'. The description adds that it's for 'a specific movie using its TMDB ID', reinforcing the schema but not providing additional semantics like format examples or validation rules. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 specific movie', specifying it uses a TMDB ID. It distinguishes from siblings like search_movies (which searches) or get_movie_credits (which focuses on credits), but doesn't explicitly contrast them. The purpose is specific and actionable, though sibling differentiation is implicit rather than explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you have a specific TMDB movie ID and need comprehensive details, suggesting an alternative to search_movies if you don't have an ID. However, it doesn't explicitly state when to use this vs. alternatives like get_movie_credits for cast info or discover_movies for browsing. Guidelines are present but not fully articulated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 the tool returns similar shows based on user preferences, but lacks details on behavioral traits: it doesn't specify if this is a read-only operation, potential rate limits, authentication needs, error handling, or what happens with invalid inputs. 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences with zero waste: the first states the purpose, and the second explains the return mechanism. It's front-loaded with the core function and efficiently communicates essential information without redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
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 output schema, no annotations), the description is minimally adequate. It covers the basic purpose and return type but lacks completeness in behavioral context (e.g., safety, errors) and doesn't compensate for the absence of an output schema by describing return values. It meets the minimum viable threshold but has clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear descriptions for both parameters (tv_id as TMDB ID, page for pagination). The description adds no additional parameter semantics beyond what the schema provides—it doesn't explain format constraints, example values, or how recommendations are influenced by the tv_id. Baseline 3 is appropriate since the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get TV show recommendations based on a specific show' (verb+resource) and 'Returns similar shows that users who liked the given show also enjoyed' (mechanism). It distinguishes from siblings like 'discover_tv_shows' or 'search_tv_shows' by focusing on similarity-based recommendations rather than discovery or search. However, it doesn't explicitly differentiate from 'get_recommendations' (which might be generic), preventing 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.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you have a specific TV show ID and want similar recommendations, but it doesn't explicitly state when to use this tool versus alternatives like 'discover_tv_shows' (which might be for broader discovery) or 'get_recommendations' (if that's a sibling). There's no guidance on prerequisites, exclusions, or comparisons with other tools, leaving some ambiguity for the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states what data is returned (actors with characters, crew with roles/departments). It lacks behavioral details like whether this is a read-only operation, rate limits, authentication needs, error conditions, or pagination behavior for large casts.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each earn their place: the first states the purpose, the second specifies the return format. It's front-loaded with the core functionality and wastes no words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter read tool with no annotations and no output schema, the description is adequate but incomplete. It explains what data is returned but not the structure, format, or potential limitations. Given the simplicity, it meets minimum requirements but lacks depth for optimal agent understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 100% description coverage (movie_id parameter is fully documented as 'TMDB movie ID'), so the baseline is 3. The description adds no additional parameter information beyond what the schema already provides, maintaining the minimum viable level.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
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 specific verbs ('Get cast and crew information') and resource ('for a specific movie'), distinguishing it from siblings like get_movie_details or get_tv_credits by focusing on personnel data rather than general movie info or TV credits.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when needing cast/crew data for a movie, but provides no explicit guidance on when to use this versus alternatives like get_movie_details (which might include credits) or search_people. It lacks explicit when-not-to-use or prerequisite information.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 describes the return content ('comprehensive details including number of seasons, episodes, networks, creators, and more'), which is helpful. However, it lacks information on potential errors (e.g., invalid ID handling), rate limits, authentication needs, or response format specifics, leaving gaps for a read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose and followed by specifics on return details. Every word contributes value without redundancy, making it efficient and easy to parse. There is no wasted text or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (single parameter, read-only operation) and lack of output schema, the description provides adequate context for basic use but has gaps. It explains what the tool does and what it returns, but without annotations or output schema, it doesn't cover error handling, response structure, or integration nuances, making it minimally complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'tv_id' fully documented in the schema as 'TMDB TV show ID.' The description adds no additional parameter details beyond what's in the schema, such as format examples or validation rules. According to guidelines, baseline is 3 when schema coverage is high (>80%) and no param info is added in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get detailed information') and resource ('specific TV show using its TMDB ID'), making the purpose immediately understandable. It distinguishes from siblings like 'get_tv_credits' or 'get_tv_recommendations' by focusing on comprehensive show details rather than credits or recommendations. However, it doesn't explicitly contrast with 'search_tv_shows' which might also return TV show information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by mentioning 'specific TV show using its TMDB ID,' suggesting this tool is for known IDs rather than discovery. However, it doesn't explicitly state when to use this versus alternatives like 'search_tv_shows' (for unknown IDs) or 'discover_tv_shows' (for browsing). No exclusions or prerequisites are provided, leaving some ambiguity in tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 the search returns 'basic info' and lists some fields, but doesn't cover important aspects like pagination behavior (implied by the 'page' parameter but not explained), rate limits, authentication requirements, error conditions, or whether results are filtered/sorted. For a search tool with zero annotation coverage, this leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that efficiently conveys the tool's purpose, input, and output without any wasted words. It's front-loaded with the core action ('Search for people by name') and adds necessary details about return fields. Every part earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (search with pagination), no annotations, and no output schema, the description is partially complete. It covers the basic purpose and return fields but lacks details on behavioral aspects like pagination mechanics, error handling, or result structure. It's adequate as a minimum viable description but has clear gaps that could hinder effective tool use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 both parameters ('query' and 'page') adequately. The description adds marginal value by implying the 'query' parameter is for person names and that results include movies/TV shows, but doesn't provide additional syntax, format, or constraints beyond what the schema states. 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.
Purpose5/5
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 specific verb ('Search for people') and resource ('people (actors, directors, producers, crew)'), distinguishing it from sibling tools like search_movies or search_tv_shows. It specifies the search criteria ('by name') and the type of information returned ('basic info including profile photo, known for department, and movies/TV shows they're known for').
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by specifying 'search for people by name' and listing return fields, but it doesn't explicitly state when to use this tool versus alternatives like get_person_details (which might retrieve detailed info for a known person ID) or search_movies/search_tv_shows (for content rather than people). No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. While it mentions filtering capabilities, it doesn't disclose important behavioral traits like pagination behavior (implied by 'page' parameter but not explained), rate limits, authentication requirements, or what happens when no filters are applied. The examples help but don't cover operational aspects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured in two sentences: first states the core functionality, second provides concrete usage examples. Every word earns its place with zero waste, and it's appropriately front-loaded with the main purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 9 parameters with full schema coverage but no annotations or output schema, the description provides adequate purpose and examples but lacks behavioral context needed for a discovery tool. It doesn't explain response format, pagination, or error conditions, leaving gaps despite good parameter documentation elsewhere.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 9 parameters thoroughly. The description adds minimal value beyond the schema by listing filter categories in general terms but doesn't provide additional semantic context or usage nuances. 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.
Purpose5/5
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 'Discover movies with advanced filters' and lists specific filter types (genre, language, year range, rating, sorting). It distinguishes from siblings like search_movies (likely keyword-based) and get_movie_details (single movie focus) by emphasizing filtered discovery.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('Perfect for finding movies that match specific criteria') with concrete examples. However, it doesn't explicitly state when NOT to use it or name specific alternatives among siblings (e.g., search_movies vs. discover_movies).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 the tool returns similar movies and is 'Great for suggestions,' but lacks details on permissions, rate limits, pagination behavior (beyond the schema's page parameter), or what happens with invalid movie IDs. For a tool with no annotation coverage, this is a significant gap in describing behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, with two sentences that efficiently convey the core purpose and usage context. Every sentence earns its place by adding value: the first defines the tool, and the second clarifies its practical application. There is no wasted text or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
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 output schema, no annotations), the description is adequate but incomplete. It covers the purpose and basic usage but lacks behavioral details like error handling or output format. Without annotations or an output schema, the description should do more to compensate, but it meets a minimum viable level for clarity and differentiation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 both parameters (movie_id and page) fully. The description adds no additional meaning beyond what the schema provides, such as explaining the recommendation algorithm or typical output size. 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.
Purpose5/5
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 specific verbs ('Get movie recommendations based on a specific movie') and distinguishes it from siblings by specifying it's for 'If you liked X, try Y' suggestions, unlike tools like get_movie_details or search_movies. It explicitly identifies the resource (movie recommendations) and the basis (specific movie).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('based on a specific movie' for 'If you liked X, try Y' suggestions), which differentiates it from siblings like get_trending (general trends) or search_movies (keyword-based). However, it doesn't explicitly state when not to use it or name specific alternatives, such as get_tv_recommendations for TV shows.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses the return format (actors with characters, crew with roles/departments) but omits behavioral traits like rate limits, authentication needs, or pagination. It's adequate but has gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences with zero waste: the first states the purpose, the second specifies the return format. It's appropriately sized and front-loaded with essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and a simple single-parameter input, the description is reasonably complete for a read-only tool. It explains what the tool does and what it returns, though could benefit from more behavioral context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 the tv_id parameter as 'TMDB TV show ID'. The description adds no additional parameter semantics beyond what the schema provides, meeting the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific verb ('Get') and resource ('cast and crew information for a specific TV show'), distinguishing it from siblings like get_tv_details (general details) and get_movie_credits (movie-specific). It precisely identifies what information is retrieved.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by specifying 'for a specific TV show' and distinguishes from siblings through its focus on credits, but lacks explicit when-not-to-use guidance or named alternatives. It's clear but not comprehensive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![tmdb-mcp-server MCP server](https://glama.ai/mcp/servers/tcehjaava/tmdb-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/tcehjaava/tmdb-mcp-server)

Score Badge

Copy to your README.md:

[![tmdb-mcp-server MCP server](https://glama.ai/mcp/servers/tcehjaava/tmdb-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/tcehjaava/tmdb-mcp-server)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/tcehjaava/tmdb-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server