Skip to main content
Glama
aahl

MCP Server for notify to weixin / telegram / bark / lark

by aahl

Telegram send video

tg_send_video

Send video messages to Telegram using a bot. Supports optional cover image, caption with parse modes, and reply to specific messages.

Instructions

Send video via telegram bot

Input 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` async function that executes the tool logic. It accepts a video URL or base64 data URI, optional cover, chat_id, caption, parse_mode, and reply_to_message_id. It handles base64 decoding, 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 `@mcp.tool()` decorator registering the tool with title 'Telegram send video' and description 'Send video via telegram bot'.
    @mcp.tool(
        title="Telegram send video",
        description="Send video via telegram bot",
    )
  • Pydantic Field definitions for the tool's parameters: video (str), cover (str), chat_id (str), caption (str), parse_mode (str), reply_to_message_id (int).
        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"),
    ):
  • Registration call `tgbot.add_tools(mcp)` which adds all telegram tools including tg_send_video to the MCP server.
    tgbot.add_tools(mcp)

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed1 schema field changedv0.1.11
    • changedInput schema / properties / video / description
      Previous value: -"Video URL"New value: +"Video URL or base64 data URI (e.g., data:video/mp4;base64,..."
  2. Changed1 schema field changedv1.0.0
    • addedInput schema / properties / reply_to_message_id
      Added value: +{
      +  "default": 0,
      +  "description": "Identifier of the message that will be replied to",
      +  "type": "integer"
      +}
  3. First observed

TDQS

C2.9/5.0
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.