The VideoDB Director server allows you to manage, process, and interact with multimedia content, particularly videos, using a variety of tools and agents.
Create and manage video applications using the doc_assistant tool
Write code related to videos or VideoDB SDK with the code_assistant tool
Play videos from provided stream links using the play_video tool
Orchestrate multimedia tasks with the call_director tool, including:
Uploading and downloading media (video, audio, image)
Indexing and searching video content (spoken words, scenes)
Summarizing videos and adding subtitles
Dubbing videos into different languages
Generating videos, audio, and images using various models
Editing and combining videos and audio files
Voice cloning and video censorship
Streaming videos and searching for online videos
Transcribing video content
Providing pricing and usage information
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., "@VideoDB Director search for videos about machine learning tutorials"
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.
To add the MCP server in any config driven MCP Client, following is how the commands and arguments will look like
uvWe need to install uv first.
For macOS/Linux:
curl -LsSf https://astral.sh/uv/install.sh | shFor Windows:
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"You can also visit the installation steps of uv for more details here
Related MCP server: OpenTool
You can run the MCP server using uvx using the following command
uvx videodb-director-mcp --api-key=VIDEODB_API_KEYTo configure VideoDB Director MCP server in Claude, you can run the following command
uvx videodb-director-mcp --install=claude
You can manually configure the MCP Server by following these steps:
Open the claude_desktop_config.json file
In MacOS/Linux:
code ~/Library/Application\ Support/Claude/claude_desktop_config.jsonIn Windows:
code $env:AppData\Claude\claude_desktop_config.jsonAdd the VideoDB Director MCP Server inside the mcpServers key:
{
"mcpServers": {
"videodb-director": {
"command": "uvx",
"args": ["videodb-director-mcp", "--api-key=<VIDEODB-API-KEY>"]
}
}
}To configure VideoDB Director MCP server in Cursor, you can run the following command
uvx videodb-director-mcp --install=cursor
You can manually configure the MCP Server by following these steps:
Inside Cursor, go to Settings > Cursor Settings
Click on MCP
Click on Add new Global MCP Server
Add the VideoDB Director MCP Server under the mcpServers key
{
"mcpServers": {
"videodb-director": {
"command": "uvx",
"args": ["videodb-director-mcp", "--api-key=<VIDEODB-API-KEY>"]
}
}
}You can configure VideoDB Director MCP server in Claude and Cursor together, by running the following command
uvx videodb-director-mcp --install=allclaude mcp add videodb-director uvx -- videodb-director-mcp --api-key=<VIDEODB_API_KEY>To ensure you're using the latest version of the MCP server with uvx, start by clearing the cache:
uv cache cleanThis command removes any outdated cached packages of videodb-director-mcp, allowing uvx to fetch the most recent version.
If you always want to use the latest version of the MCP server, update your command as follows:
uvx videodb-director-mcp@latest --api-key=<VIDEODB_API_KEY>The Director tool orchestrates specialized agents within the VideoDB server, efficiently handling multimedia and video-related queries. Clients should send queries that Director can interpret clearly, specifying tasks in natural language. Director will then delegate these queries to appropriate agents for optimized results, utilizing defaults and contextual information if explicit parameters are not provided.
Director handles queries such as:
Uploading & Downloading:
Upload media from URLs or local paths (supported media: video, audio, image)
Download the VideoDB generated video streams.
Indexing & Search:
Index spoken words or scenes in videos (spoken_words, scene indexing; scene indexing supports shot or time-based type)
Search VideoDB collections semantically or by keyword (semantic, keyword search; indexing types: spoken_word, scene)
Summarization & Subtitles:
Summarize video content based on custom prompts
Add subtitles in various languages
Dubbing:
Dub videos into target languages
Creating Videos:
Generate videos using specific models or engines (Fal, StabilityAI; job types: text_to_video, image_to_video)
Compare multiple video generation models (video_generation_comparison)
Audio Generation & Editing:
Generate speech, sound effects, or background music (engines: ElevenLabs for speech/sound effects, Beatoven for music)
Clone voices from audio sources or overlay cloned voices onto videos
Censor the video on given prompt
Image and Frame Generation:
Generate static image frames from videos at specified timestamps
Create or enhance images using GenAI models (job types: text_to_image, image_to_image using Fal, Replicate)
Video Editing & Clip Generation:
Edit or combine multiple videos and audio files
Generate targeted video clips from user prompts
Streaming & Web Search:
Stream videos by video ID or URL
Search for relevant online videos (engine: Serp)
Transcription:
Generate transcripts for videos
Pricing & Usage Information:
Provide detailed cost information and usage estimates
Meeting Recording & Analysis:
Record meetings
Deploy recording bots to Zoom, Google Meet, or Microsoft Teams
Analyze recorded meetings for AI-driven insights
Intelligently index and summarize meetings
Clients should provide queries clearly aligned with Director's capabilities, allowing Director to use contextual defaults when explicit parameters like IDs or collection details are not specified.
IMPORTANT: if you have a previous response of this method with an appropriate session_id, please provide that session_id in the next request to continue the conversation.
IMPORTANT: It is MANDATORY to send the session_id param if any earlier response from this method exists with a session_id in its output
| Name | Required | Description | Default |
|---|---|---|---|
| agents | No | ||
| session_id | No | ||
| text_message | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers limited behavioral insight. It mentions using 'defaults and contextual information if explicit parameters are not provided' and session_id continuity, but doesn't cover critical aspects like authentication needs, rate limits, error handling, or what 'orchestrates' entails operationally. The description doesn't contradict annotations (none exist), but it's insufficient for a tool with such broad capabilities.
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 overly verbose and poorly structured, with a long bulleted list of examples that could be summarized. It front-loads core purpose but buries important session_id instructions at the end. Many sentences (e.g., detailed task examples) don't earn their place for tool selection, making it inefficient for an AI agent.
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 (broad multimedia orchestration), 3 parameters with 0% schema coverage, no annotations, and an output schema (which reduces need for return value explanation), the description is incomplete. It lists capabilities but lacks operational context, parameter guidance, and behavioral transparency needed for effective tool use, leaving major gaps despite the output 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 0%, so the description must compensate but adds minimal parameter semantics. It vaguely references 'queries' and 'contextual defaults,' but doesn't explain the three parameters (agents, session_id, text_message) or their relationships. The IMPORTANT notes about session_id provide some usage context but not parameter meaning. With 3 parameters undocumented in both schema and description, this is a significant gap.
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 that the tool 'orchestrates specialized agents within the VideoDB server' to 'handle multimedia and video-related queries' through delegation. It specifies the verb (orchestrate/delegate) and resource (VideoDB agents), though it doesn't explicitly differentiate from sibling tools like code_assistant or doc_assistant beyond the multimedia focus.
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 by stating clients should send 'queries that Director can interpret clearly' and 'aligned with Director's capabilities,' with examples of supported tasks. However, it lacks explicit guidance on when to use this tool versus alternatives like play_video, and doesn't mention prerequisites or exclusions beyond query clarity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Will give you data related to VideoDB SDK which allows developers to use videodb in python. IMPORTANT: Whenever user wants to write code related to videos, youtube videos or VideoDB specifically, always call this tool.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
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 'will give you data' but doesn't disclose behavioral traits such as what type of data (e.g., read-only, generated code), potential side effects, authentication needs, or rate limits. The description is insufficient 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences and front-loaded with the purpose, but the second sentence is repetitive ('always call this tool') and could be more structured. It's concise but lacks optimal efficiency in phrasing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters, annotations, but an output schema exists, the description is moderately complete. It states the purpose and usage but lacks details on what data is provided, behavioral context, or how it differs from siblings, leaving gaps in understanding the tool's full 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 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate, earning a baseline score of 4 for tools with no 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 states the tool provides 'data related to VideoDB SDK' and is for 'code related to videos, youtube videos or VideoDB specifically', which gives a general purpose. However, it's vague about what specific data or actions it provides (e.g., examples, documentation, code snippets) and doesn't clearly distinguish from sibling tools like 'doc_assistant' or 'play_video'.
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 explicitly states when to use this tool: 'Whenever user wants to write code related to videos, youtube videos or VideoDB specifically, always call this tool.' This provides clear, directive guidance on usage context, though it doesn't mention when not to use it or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Context for creating video applications using VideoDB
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
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. The description hints at providing 'context' for video application creation, but it doesn't specify what this entails—whether it's informational, instructional, or involves data retrieval. It lacks details on permissions, side effects, or response format, leaving 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, concise sentence: 'Context for creating video applications using VideoDB.' It's front-loaded and wastes no words, making it efficient. However, it could be more structured if it included clearer purpose or usage hints, but as-is, it's appropriately sized for its limited content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 0 parameters, 100% schema coverage, and an output schema exists, the description doesn't need to explain parameters or return values. However, the description is vague about the tool's purpose and behavior, and with no annotations, it leaves gaps in understanding what 'context' means and how it aids in video application creation. It's minimally adequate but lacks depth for a tool that might involve complex operations.
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 0 parameters, and the schema description coverage is 100%, so there's no need for parameter details in the description. The description doesn't mention parameters, which is appropriate. A baseline of 4 is given for zero-parameter tools, as there's no semantic gap to fill beyond what the schema already indicates.
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 'Context for creating video applications using VideoDB' is vague about what the tool actually does. It mentions 'context' and 'creating video applications' but doesn't specify a clear action or resource. It's not a tautology since it adds some information beyond the name 'doc_assistant', but it fails to distinguish what specific function this tool performs compared to its siblings like 'code_assistant' or 'play_video'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions 'creating video applications' but doesn't clarify if this is for setup, documentation, or another purpose, nor does it reference sibling tools like 'code_assistant' or 'play_video' for comparison. There's no explicit or implied context for usage decisions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Play the video of the given stream link
| Name | Required | Description | Default |
|---|---|---|---|
| stream_link | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Play') but doesn't explain what 'Play' entails—e.g., does it open a player, stream in background, require specific permissions, or have rate limits? This leaves key behavioral traits undefined.
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 function without unnecessary words. It's appropriately sized and front-loaded, making it easy to grasp quickly with zero waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (which covers return values), the description's minimalism is somewhat acceptable. However, with no annotations and low schema coverage, it lacks completeness for a tool that performs an action like 'Play'—missing behavioral context and parameter details leaves gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate. It mentions 'stream_link' but doesn't add meaning beyond the schema's basic type and title—no details on format, valid URLs, or examples. This fails to adequately clarify the parameter's semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Play') and the resource ('video of the given stream link'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'call_director' or 'doc_assistant', which appear unrelated, so it doesn't fully distinguish itself in context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as whether it's for streaming specific formats or in certain contexts. It lacks explicit instructions on prerequisites, exclusions, or comparisons with sibling tools, leaving usage ambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0call_directorcode_assistantdoc_assistantplay_videoThe tools are highly ambiguous and overlapping. The 'call_director' tool appears to be a monolithic interface that handles nearly all functionality described (uploading, indexing, summarization, dubbing, video creation, audio generation, video editing, streaming, transcription, pricing, meeting analysis, etc.), making it unclear when to use the other tools. 'code_assistant' and 'doc_assistant' might overlap in providing development support, and 'play_video' could be seen as a subset of 'call_director's streaming capability. This creates significant confusion for tool selection.
Naming is inconsistent with mixed conventions. 'call_director' uses a verb_noun pattern, 'code_assistant' and 'doc_assistant' use noun_noun patterns, and 'play_video' uses verb_noun. While readable, the lack of a uniform pattern (e.g., all verb_noun like 'call_director', 'assist_code', 'assist_docs', 'play_video') reduces predictability. The styles vary without a clear rationale, though they are not chaotic.
The tool count of 4 is too few for the broad scope implied by the 'call_director' description, which covers over 20 distinct capabilities (e.g., uploading, indexing, dubbing, video generation). This forces a single tool to handle too many diverse operations, making the surface feel thin and under-scoped. A more appropriate set would break these into multiple specialized tools for better coherence.
The tool set is severely incomplete relative to the domain described. While 'call_director' lists many video-related operations, the other tools ('code_assistant', 'doc_assistant', 'play_video') do not provide complementary CRUD or lifecycle coverage. For example, there are no dedicated tools for core actions like 'upload_video', 'search_videos', or 'transcribe_video', leaving agents to rely on a single monolithic tool that may not handle all scenarios effectively, leading to potential dead ends.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
MCP-first toolbox for agents: KV storage, auth, queue, and utility tools. Free in early access.
Agent-native notes, tasks, dev-docs, vaults, sync & handoffs. MCP + OpenAPI dual surface.
A registry of AI agent tools — MCP servers, APIs, CLIs, SDKs — kept current by automated ingestion.
Package intelligence MCP for AI agents — 22 tools, 19 ecosystems, AGPL SDK, free.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/video-db/agent-toolkit'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
