Skip to main content
Glama

Telegram send video

tg_send_video

Send a video to a Telegram chat using a URL or base64 data. Optionally add a caption, cover image, or reply to a specific message.

Instructions

Send video via telegram bot

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
videoYesVideo URL or base64 data URI (e.g., data:video/mp4;base64,...
coverNoCover for the video in the message. Optional
chat_idNoTelegram chat id, Default to get from environment variables
captionNoVideo caption, 0-1024 characters after entities parsing
parse_modeNoMode for parsing entities in the caption. [text/MarkdownV2]
reply_to_message_idNoIdentifier of the message that will be replied to

Implementation Reference

  • The tg_send_video function is the handler that sends a video via Telegram bot. It accepts video (URL or base64 data URI), cover, chat_id, caption, parse_mode, and reply_to_message_id. It handles base64 decoding for data URIs, then calls bot.send_video() and returns the result as JSON.
    async def tg_send_video(
        video: str = Field(description="Video URL or base64 data URI (e.g., data:video/mp4;base64,..."),
        cover: str = Field("", description="Cover for the video in the message. Optional"),
        chat_id: str = Field("", description="Telegram chat id, Default to get from environment variables"),
        caption: str = Field("", description="Video caption, 0-1024 characters after entities parsing"),
        parse_mode: str = Field("", description=f"Mode for parsing entities in the caption. [text/MarkdownV2]"),
        reply_to_message_id: int = Field(0, description="Identifier of the message that will be replied to"),
    ):
        if parse_mode == TELEGRAM_MARKDOWN_V2:
            caption = telegramify_markdown.markdownify(caption)
    
        if video.startswith("data:"):
            match = re.match(r"data:video/([^;]+);base64,(.*)", video)
            if not match:
                return {"error": "Invalid base64 data URL format"}
            try:
                datas = base64.b64decode(match.group(2))
                video = InputFile(io.BytesIO(datas), f"video.{match.group(1)}")
            except Exception as e:
                return {"error": f"Failed to decode base64: {str(e)}"}
    
        res = await bot.send_video(
            chat_id=chat_id or TELEGRAM_DEFAULT_CHAT,
            video=video,
            cover=cover or None,
            caption=caption or None,
            parse_mode=parse_mode if parse_mode in [TELEGRAM_MARKDOWN_V2] else None,
            reply_to_message_id=reply_to_message_id or None,
        )
        return res.to_json()
  • The function signature uses Pydantic Field annotations that serve as the input schema/validation for the tool, defining types, defaults, and descriptions for video, cover, chat_id, caption, parse_mode, and reply_to_message_id.
    async def tg_send_video(
        video: str = Field(description="Video URL or base64 data URI (e.g., data:video/mp4;base64,..."),
        cover: str = Field("", description="Cover for the video in the message. Optional"),
        chat_id: str = Field("", description="Telegram chat id, Default to get from environment variables"),
        caption: str = Field("", description="Video caption, 0-1024 characters after entities parsing"),
        parse_mode: str = Field("", description=f"Mode for parsing entities in the caption. [text/MarkdownV2]"),
        reply_to_message_id: int = Field(0, description="Identifier of the message that will be replied to"),
  • The tool is registered via the @mcp.tool() decorator with title 'Telegram send video' and description 'Send video via telegram bot'. This is inside the add_tools() function which is called from __init__.py.
    @mcp.tool(
        title="Telegram send video",
        description="Send video via telegram bot",
    )
Behavior1/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, and description gives no behavioral details beyond 'send video' - no mention of authentication, rate limits, or side effects. Minimal transparency for a mutation tool.

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?

Single sentence of 5 words - extremely concise, no redundancy, appropriately front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness1/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite 6 parameters and no output schema/annotations, description only says 'send video'. Lacks details on return values, prerequisites (bot token), constraints (file size limits), or error conditions. Inadequate for a tool with this complexity.

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 parameters are well documented. Description adds no extra meaning beyond schema, but baseline 3 is appropriate.

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?

Description clearly states 'Send video via telegram bot' - specific verb and resource, and distinguishes from sibling tools like tg_send_audio and tg_send_photo.

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?

No guidance on when to use this tool vs alternatives (e.g., tg_send_photo, tg_send_file). No exclusion criteria or context provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

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/aahl/mcp-notify'

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