OTT Helper MCP Server
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@OTT Helper MCP ServerFind action movies on Netflix with rating 8 or higher"
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.
OTT Helper MCP Server
A Model Context Protocol (MCP) server that provides intelligent OTT (Over-The-Top) content recommendations based on IMDB ratings, platform availability, and genre preferences.
Features
Platform-based Recommendations: Get content recommendations from specific OTT platforms (Netflix, Prime Video, Jio Hotstar, Sony Liv, and more)
Genre-based Filtering: Find content by genre (action, drama, sci-fi, etc.)
Rating-based Filtering: Filter content by minimum IMDB rating
Combined Criteria Search: Search by platform + genre + rating simultaneously
Content Search: Search for specific titles
Top-Rated Content: Get the highest-rated content across all platforms
Detailed Information: Get comprehensive details about specific content
Related MCP server: Indian Movies MCP Agent
Available Platforms
Netflix
Prime Video (prime)
Jio Hotstar (hotstar)
Sony Liv (sony)
Peacock
Apple TV+
Hulu
Disney+
Zee5
JioCinema
Available Genres
Action
Comedy
Drama
Sci-Fi
Thriller
Horror
Romance
Adventure
Crime
Mystery
Fantasy
History
Biography
Animation
Documentary
Installation
Install dependencies:
npm installBuild the project:
npm run buildUsage
With Claude Desktop
Add the server to your Claude configuration file:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
{
"mcpServers": {
"ott-helper": {
"command": "node",
"args": ["/absolute/path/to/OTTHelper/build/index.js"]
}
}
}Restart Claude Desktop
Use the tools in your conversations to get OTT recommendations
With VS Code or Other Clients
Add the server configuration to your mcp.json file:
{
"servers": {
"ott-helper": {
"type": "stdio",
"command": "node",
"args": ["/path/to/OTTHelper/build/index.js"]
}
}
}Demo Video
Available Tools
1. get_recommendations_by_platform_and_rating
Get recommendations filtered by platform and minimum IMDB rating.
Parameters:
platform(required): OTT platform nameminRating(required): Minimum IMDB rating (0-10)contentType(optional): "movie", "series", or "both"
Example:
Get me action movies on Netflix with rating >= 8
2. get_recommendations_by_genre_and_rating
Get recommendations filtered by genre and minimum IMDB rating.
Parameters:
genre(required): Genre of contentminRating(required): Minimum IMDB rating (0-10)contentType(optional): "movie", "series", or "both"
Example:
Get me drama movies with rating >= 8
3. get_recommendations_by_criteria
Get recommendations filtered by platform, genre, and rating simultaneously.
Parameters:
platform(required): OTT platformgenre(required): GenreminRating(required): Minimum ratingcontentType(optional): "movie" or "series"
Example:
Get me sci-fi series on Netflix with rating >= 8
4. get_all_content_on_platform
Get all available content on a specific platform.
Parameters:
platform(required): OTT platformsortByRating(optional): Sort by rating (default: true)
Example:
Get all content available on Prime Video
5. get_top_rated_content
Get the highest-rated OTT content.
Parameters:
limit(optional): Maximum number of results (default: 10)genre(optional): Filter by genrecontentType(optional): "movie" or "series"
Example:
Get the top 5 rated movies
6. search_content_by_title
Search for content by title.
Parameters:
title(required): Title or partial titleexactMatch(optional): Require exact match (default: false)
Example:
Search for "Breaking Bad"
7. get_available_filters
Get all available platforms and genres for filtering.
Example:
What are the available filters?
8. get_content_details
Get detailed information about specific content.
Parameters:
title(required): Title of the content
Example:
Get details about "Inception"
Architecture
The server consists of:
src/index.ts: Main MCP server with tool definitions and request handlerssrc/database.ts: Sample OTT content database with movies and seriestsconfig.json: TypeScript configurationpackage.json: Project dependencies and build scripts
Building and Running
Development mode:
npm run devBuild:
npm run buildRun built version:
npm startSample Data
The server comes with sample data including popular movies and TV series like:
Breaking Bad
The Office
Inception
Stranger Things
And more!
You can extend the database by modifying the ottDatabase array in src/database.ts.
Future Enhancements
Integration with real OTT APIs for live content updates
User preferences and personalized recommendations
Watch history tracking
Rating and review system
Multi-language support
Advanced ML-based recommendation algorithms
License
MIT
Available Tools
8 toolsget_all_content_on_platformA
Get all available content on a specific platform
| Name | Required | Description | Default |
|---|---|---|---|
| platform | Yes | OTT platform name | |
| sortByRating | No | Sort results by IMDB rating (highest first) - default: true |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The verb 'Get' implies a read-only operation with no side effects, but the description does not explicitly state that it does not modify data or mention any permissions or limitations. Since no annotations are provided, the description carries the burden but only partially covers behavioral 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, concise sentence with no redundant information. It is well-structured and immediately understandable, making it easy for an agent to parse.
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?
The tool is simple and the schema fully documents inputs. However, there is no output schema and the description does not mention pagination, return format, or potential size constraints. Given the low complexity, this is mostly sufficient, but a bit more detail about the response would improve 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 schema covers 100% of parameters with descriptions, including the enum values and the default for sortByRating. The description does not add any additional semantic detail beyond the schema, so a 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: retrieving all content on a given platform. It uses a specific verb ('Get') and resource ('content'), and the platform scope is explicit. This distinguishes it from sibling tools that focus on recommendations or search.
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 explicit guidance on when to use this tool versus its siblings. While the name and description imply it is for broad retrieval, it does not direct users to alternatives like 'search_content_by_title' for narrower queries or 'get_recommendations_by_platform_and_rating' for filtered results.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_available_filtersA
Get all available platforms and genres for filtering
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. The verb 'Get' clearly indicates a read-only, non-destructive operation. There are no side effects, rate limits, or other behavioral traits to disclose for such a simple tool, so the description adequately covers 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?
A single, efficient sentence that front-loads the verb and resource. Every word earns its place, with no unnecessary elaboration or repetition.
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 zero-parameter, no-output-schema tool, the description is complete enough. It identifies the returned data categories. It does not specify the exact format (e.g., array of objects, separate lists), but this is a minor gap for a simple list retrieval.
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 tool has zero parameters, so there is nothing to document beyond the schema. The description adds value by specifying exactly what data is returned (platforms and genres), which helps the agent understand the output without needing an output schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Get') and the resource ('available platforms and genres') with a clear purpose ('for filtering'). It is immediately distinct from the sibling tools, which all focus on recommendations, search, or content details.
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 tool is a simple lookup utility with no parameters. Its purpose is clear from the description, and it is not ambiguous when to use it compared to siblings. However, it does not explicitly mention alternatives or provide any contextual 'when to use' guidance, but the distinct nature makes that unnecessary.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_content_detailsC
Get detailed information about a specific content
| Name | Required | Description | Default |
|---|---|---|---|
| title | Yes | Title of the content to get details for |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Get detailed information'. It does not state whether the operation is read-only, what happens when the title is not found, whether authentication is needed, or what the returned details contain.
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 concise sentence with no filler or repetition. It is somewhat generic, but it is efficiently structured and immediately understandable.
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 one-parameter retrieval tool, the description is minimally adequate, but the absence of an output schema and any mention of the shape of 'detailed information' leaves a gap. An agent would not know what to expect in the response or how to handle a missing title.
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 title parameter is already fully documented. The description adds no extra meaning about the parameter beyond the schema, which matches the baseline for fully covered schemas.
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 states a clear action and object: 'Get detailed information about a specific content'. The required title parameter clarifies what makes the content specific. It does not explicitly differentiate itself from sibling search_content_by_title, but the read-details intent is understandable.
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?
No guidance is provided for when to call this tool versus siblings such as search_content_by_title or get_top_rated_content. The description does not mention prerequisites, exclusions, or alternative routing, leaving the agent to infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_recommendations_by_criteriaB
Get OTT recommendations filtered by platform, genre, and minimum IMDB rating
| Name | Required | Description | Default |
|---|---|---|---|
| genre | Yes | Genre of content | |
| platform | Yes | OTT platform name | |
| minRating | Yes | Minimum IMDB rating (0-10) | |
| contentType | No | Filter by content type: movie, series, or both (default: both) |
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 does not mention that the operation is read-only, what the return format looks like, or any side effects, rate limits, or error behavior. The description is minimal and leaves much to the agent's interpretation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no unnecessary words or redundancy. It efficiently conveys the core purpose without fluff.
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 an output schema, the description should ideally indicate the return type (e.g., a list of recommendations) but does not. It also does not mention the default behavior of contentType (even though the schema notes the default is 'both'), leaving some context missing.
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 provides full descriptions for all parameters, so the baseline is 3. The tool description restates three of the four parameters but adds no new semantic detail beyond what the schema already offers, and it ignores contentType entirely.
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 identifies the action (Get) and resource (OTT recommendations) and specifies the three main filters (platform, genre, minRating). However, it omits the optional contentType filter, which is present in the schema, slightly reducing completeness.
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 does not indicate when to use this tool versus the similar sibling tools like get_recommendations_by_platform_and_rating or get_recommendations_by_genre_and_rating. No conditions or alternatives are mentioned, leaving the agent to infer based on the filter combination.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_recommendations_by_genre_and_ratingB
Get OTT recommendations filtered by genre and minimum IMDB rating
| Name | Required | Description | Default |
|---|---|---|---|
| genre | Yes | Genre of content | |
| minRating | Yes | Minimum IMDB rating (0-10) | |
| contentType | No | Filter by content type: movie, series, or both (default: both) |
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 correctly discloses that results are filtered by genre and minimum rating, but does not mention the optional content type default or any result ordering/limits.
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, focused sentence with no filler or redundant wording. It front-loads the main action and key filters.
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 three-parameter schema and sibling tools, the description is mostly complete for selection. The only notable gap is not mentioning the optional contentType parameter in the description, though it is fully documented in the schema.
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%: all three parameters have descriptions and two have enums. The tool description adds no extra semantic detail beyond what the schema already provides, so the baseline score applies.
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?
Description clearly states the verb 'Get' and the resource 'OTT recommendations', with explicit filters for genre and minimum IMDB rating. It distinguishes from the platform/rating sibling but omits the content type filter, which is a parameter.
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?
No guidance is given on when to use this tool versus similar siblings like get_recommendations_by_platform_and_rating or get_recommendations_by_criteria. The intended use is implied but not explicitly contrasted.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_recommendations_by_platform_and_ratingC
Get OTT recommendations filtered by platform and minimum IMDB rating
| Name | Required | Description | Default |
|---|---|---|---|
| platform | Yes | OTT platform name (netflix, prime, hotstar, sony, peacock, apple, hulu, disney+, zee5, jiocinema) | |
| minRating | Yes | Minimum IMDB rating (0-10) | |
| contentType | No | Filter by content type: movie, series, or both (default: both) |
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 a read-like action ('get') but does not describe output format, pagination, potential rate limits, or any side effects. For a tool with no annotation coverage, this is a significant gap, as the agent cannot infer behavior beyond the basic retrieval action.
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 captures the core purpose without waste. It is appropriately concise for a simple filtering tool, though it lacks any structural elements like sections or examples. It does not under-specify the primary action.
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?
The tool has three parameters, including an optional contentType that is not mentioned in the description. There is no output schema, and the description does not explain the return value, default behavior for contentType, or how the results are ordered. For an agent to call this correctly, it needs to know the optional parameter's semantics and what to expect in response. The description is incomplete in these respects.
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% coverage, with descriptions for all three parameters including enums for platform and contentType, and a range for minRating. The description adds no additional meaning beyond the schema, so a baseline score of 3 is appropriate. It does not clarify defaults or interactions between parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves OTT recommendations filtered by platform and IMDB rating, with a specific verb and resource. It is unambiguous about its core function, but it does not explicitly differentiate itself from siblings like get_recommendations_by_genre_and_rating or get_recommendations_by_criteria, which also offer filter-based recommendations.
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?
No guidance is provided on when to use this tool versus alternatives. The description only implies usage via the filter combination, but it does not mention when to prefer it over get_recommendations_by_genre_and_rating or get_all_content_on_platform. There are no explicit conditions or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_top_rated_contentB
Get the highest-rated OTT content
| Name | Required | Description | Default |
|---|---|---|---|
| genre | No | Filter by specific genre (optional) | |
| limit | No | Maximum number of results (default: 10) | |
| contentType | No | Filter by content type (optional) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility. It states the action but does not explicitly mention that it is read-only, how the 'highest-rated' metric is defined, or that it returns a list with a default limit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no unnecessary words or details, making it highly concise and well-structured.
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 simple query tool with three optional parameters, the description is adequate. It does not specify the output format, but that is not explicitly required given the absence of an output schema. The context of 'content' and 'highest-rated' is sufficient for most agents.
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% (all three parameters have descriptions). The descriptions are concise and accurate, such as 'Filter by specific genre' and 'Maximum number of results', so the schema itself carries the semantic weight.
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 function: 'Get the highest-rated OTT content' uses a specific verb and resource, and the qualification 'highest-rated' distinguishes it from sibling tools like search_content_by_title or get_recommendations_by_platform_and_rating.
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 its siblings. It does not mention that it is appropriate for broad top-rated queries or that more specific criteria should use other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_content_by_titleB
Search for OTT content by title
| Name | Required | Description | Default |
|---|---|---|---|
| title | Yes | Title or partial title to search for | |
| exactMatch | No | Require exact title match (default: false for partial match) |
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 only restates the function without detailing return format, pagination, case sensitivity, or side effects. The description adds no behavioral context beyond what the name suggests.
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?
A single, front-loaded sentence that conveys the core purpose without waste. It is appropriately sized for a simple search tool.
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?
The description is too minimal for a tool with no output schema and no annotations. It does not mention what the response contains (e.g., list of matches, details) or any filtering behavior. An agent may need to infer the return format from context, which is a significant gap.
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%, and both parameters are described. The description adds little beyond the schema; it only mentions 'by title', which aligns with the required parameter. No extra semantic context for exactMatch is provided.
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?
Description states a clear verb ('Search') and resource ('OTT content') with a specific modifier ('by title'). It is distinct from sibling tools that focus on recommendations and platform/genre filters, so an agent can easily differentiate it.
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 usage is implied: use when searching by title. However, there is no explicit statement of when not to use it or mention of alternatives like get_recommendations_by_criteria for broader discovery. The description does not provide explicit routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
8 tool updates
v1.0.0- First observed
get_all_content_on_platform - First observed
get_available_filters - First observed
get_content_details - First observed
get_recommendations_by_criteria - First observed
get_recommendations_by_genre_and_rating - First observed
get_recommendations_by_platform_and_rating - First observed
get_top_rated_content - First observed
search_content_by_title
TDQS
Several tools overlap in functionality: get_recommendations_by_platform_and_rating and get_recommendations_by_genre_and_rating are subsets of get_recommendations_by_criteria, and get_top_rated_content may duplicate recommendation results. This could confuse an agent when choosing the appropriate tool.
Most tools follow a 'get_' prefix pattern, but 'search_content_by_title' uses 'search_' instead. The filter-based names are clear and consistent, with only minor deviations from the dominant convention.
Eight tools provide a focused yet comprehensive set for an OTT helper, avoiding both excessive granularity and insufficient coverage. The number is well balanced for the domain.
The toolset covers search, recommendations, filtering, content details, top-rated items, and available filters. Missing features like user watchlists or reviews are not essential for the stated purpose, so the surface is reasonably complete.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Movies and TV show data — search, details, ratings, and cast from iTunes and TVmaze APIs
- AchriomOAuthcom.achriom
Media memory for AI agents and their humans: books, movies, music, shows, anime, podcasts, games.
Search and get fashion products recommendations across multiple e-ecom stores
The media memory layer for AI agents and their humans. Your AI client gets 29 tools to search your collection, add items, update ratings, preview music, and find patterns across everything you've read, watched, and listened to.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceIntegrates with The Movie Database (TMDB) API to provide movie information, search capabilities, and recommendations.1975MIT
- FlicenseBqualityDmaintenanceProvides Indian movie recommendations within Claude Desktop, allowing users to filter by genre, language, rating, and year, search for specific films, or discover random recommendations from Bollywood and regional cinema.3-
- FlicenseNot gradedqualityDmaintenanceTracks movies, books, and TV shows with ratings and preferences, providing intelligent cross-media recommendations. Automatically fetches metadata from OMDB, Google Books, and TMDB to help manage watchlists and analyze viewing patterns.1-
- FlicenseAqualityCmaintenanceEnables searching for movies and TV shows and retrieving streaming availability data across multiple platforms and countries.32-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/shreyapiu/cine-ott-assist'
If you have feedback or need assistance with the MCP directory API, please join our Discord server