# Rendi MCP > Rendi connects your AI agent to a powerful cloud media processing API. It handles all video and audio tasks: converting formats, generating thumbnails, resizing assets, running complex FFmpeg commands, and analyzing technical metadata using `ffprobe`. You manage entire content pipelines—from raw footage to web-ready files—entirely through conversation. ## Overview - **Category:** industry-titans - **Price:** Free - **Tags:** ffmpeg, media-processing, video-transcoding, serverless-api, image-transformation, media-metadata ## Description **Rendi connects your AI agent straight into a massive cloud media processing API. You don't touch FFmpeg or worry about server keys; your AI client handles all the heavy lifting for video and audio tasks. Whether you're prepping raw footage for a web drop or building out complex content pipelines, this thing lets you manage it all through conversation.** **You execute single media commands:** You can run any basic FFmpeg command in the cloud using `run_ffmpeg_command`. When you send that request, the server spits back a unique job ID. You don't know if it worked yet, so you use `get_command_status` with that ID to check on its progress and grab the final output URL once the job is done. **You build chained workflows:** Need to do more than one thing? Use `run_chained_ffmpeg_commands`. This lets your agent execute multiple FFmpeg commands sequentially in a single request. For example, you could tell it to transcode a video *then* analyze the metadata—all at once. **You analyze file technical data:** You don't just need to know if a file exists; you need to know how good it is. The dedicated `ffprobe` tool pulls deep details from any media asset. It reports things like codecs, exact resolutions, bitrates, and stream counts—the whole technical rundown on the file. **You generate video previews:** You can’t show a huge raw video in an article, so you need a thumbnail. Use `generate_thumbnail` to create that specific preview image from your source video file. **You manage cloud storage assets:** You gotta know what files you've got lying around. `list_files` shows you a comprehensive list of everything stored in Rendi’s system right now. If you need the deep dive on just one asset, use `get_file_info` to fetch specific metadata and technical data for that known media asset ID. You can also get general details about any file using `get_file_details`. When you're done with a temp file, you can clean up by running `delete_file`, which removes the specified file from Rendi’s cloud storage. **The workflow is simple:** You tell your AI agent what you want—say, 'Take this 4K video and turn it into an MP3 for the podcast.' The agent uses these exposed tools to process the job on Rendi's servers and reports back the final status or the download URL. If you run a bunch of jobs, `list_commands` lets you see every single FFmpeg command that’s been submitted to the cloud service. **It all runs together:** You can send your agent raw footage, ask it to run a complex chain—like converting the video to audio using `convert_video_to_audio`, generating a thumbnail in the process with `generate_thumbnail`, and then running `ffprobe` on the resulting file. Your AI client handles that whole sequence. It manages the IDs, checks the status via `get_command_status`, and gives you exactly what you asked for. You're not dealing with command lines or writing boilerplate code; your agent acts like a dedicated technical content coordinator who knows every single tool in this kit. ## Tools ### convert_video_to_audio Converts any video file into an audio-only format. ### delete_file Removes a specific file from the Rendi cloud storage. ### ffprobe Analyzes and reports detailed technical metadata about any given media file. ### generate_thumbnail Creates a preview image (thumbnail) from the specified video source. ### get_command_status Checks if a previous FFmpeg command has completed and retrieves the output URL when done. ### get_file_details Retrieves general details about a file stored within Rendi's system. ### get_file_info Fetches specific metadata and technical data for a known media asset ID. ### list_commands Lists all FFmpeg commands that have been submitted to the cloud service. ### list_files Shows a comprehensive list of all files currently stored in Rendi storage. ### run_chained_ffmpeg_commands Executes multiple, complex FFmpeg commands sequentially within one single request. ### run_ffmpeg_command Runs a single FFmpeg command in the cloud and provides an ID to track its status. ## Prompt Examples **Prompt:** ``` Analyze this media file for technical metadata: https://example.com/video.mp4 ``` **Response:** ``` Running ffprobe analysis... I've retrieved the metadata. The video has a resolution of 1920x1080 at 30fps using the H.264 codec. Would you like me to check the audio stream details? ``` **Prompt:** ``` Convert this MP4 video to WebM format with H265 encoding and reduce the file size by 50%. ``` **Response:** ``` FFmpeg conversion completed. Input: video.mp4 (1080p, H264, 245 MB, 12:34 duration). Output: video.webm (1080p, VP9/H265, 118 MB, 51.8% size reduction). Encoding settings: CRF 28, 2-pass encoding, libvpx-vp9 codec. Quality assessment: SSIM 0.96 (excellent visual fidelity). Processing time: 4 minutes 23 seconds. The output file maintains original audio quality (AAC 128kbps converted to Opus 128kbps). Download ready. ``` **Prompt:** ``` Analyze the media properties of the uploaded video file and show me all codec and stream details. ``` **Response:** ``` FFprobe analysis complete. File: presentation.mp4. Container: MPEG-4 Part 14. Duration: 45:12. Size: 1.2 GB. Video stream: H.264 (High Profile), 1920x1080, 30fps, 3.2 Mbps bitrate, YUV420p color space. Audio stream 1: AAC LC, 48kHz, stereo, 192 kbps. Audio stream 2: AAC LC, 48kHz, 5.1 surround, 384 kbps. Subtitle stream: SRT (English). Metadata: creation date May 10, 2025, encoder: HandBrake 1.7.3. ``` ## Capabilities ### Execute single media commands Runs a basic FFmpeg command in the cloud; it returns a unique ID you poll to check if the job finished. ### Run chained workflows Executes multiple, sequential FFmpeg commands—like transcoding and then analyzing metadata—in one API call. ### Analyze file technical data Uses `ffprobe` to extract deep details from any media file, including codecs, resolutions, and bitrates. ### Generate video previews Creates a specific thumbnail image from a source video file using the `generate_thumbnail` tool. ### Manage cloud storage assets Allows listing all stored files (`list_files`) or getting detailed metadata about a specific asset with `get_file_info`. ## Use Cases ### Standardizing assets for a website A content engineer needs 10 videos converted from 4K ProRes to web-friendly WebM format, and they all need an accompanying thumbnail. Instead of writing 10 separate scripts, the agent runs `run_chained_ffmpeg_commands` in one go. The process handles transcode, resize, and thumbnail generation for every file listed via `list_files`. ### Debugging a broken video stream A video producer uploads a new asset but the client complains about poor audio quality. They prompt the agent to analyze it. The agent uses `ffprobe`, which immediately reports that the audio bitrate is too low (e.g., 64 kbps instead of 128 kbps). This tells the producer exactly what parameter needs fixing in the next transcoding attempt. ### Building an asset ingestion pipeline An operations team wants to process a batch of raw footage. First, they ask the agent to `run_ffmpeg_command` to convert all MP4s to WAV (video to audio). Then, they use `list_commands` and `get_file_info` to track the IDs and ensure every single file finished transcoding before moving on. ### Creating a media manifest A developer needs a list of all available assets for an API endpoint. They use `list_files` to get asset names, then loop through them using the agent and call `get_file_info` on each one to pull out crucial metadata like creation date, resolution, and codec type into a structured manifest. ## Benefits - No server management needed. Instead of dealing with SSH keys and cloud worker configurations, you just ask your agent to run a job. Rendi handles the entire execution layer for all 11 tools. - Complex pipelines are simple. Use `run_chained_ffmpeg_commands` to sequence tasks—for example, first running `generate_thumbnail`, then piping that result into an analysis step with `ffprobe`. It’s one prompt, multiple actions. - Metadata is instant. The `ffprobe` tool lets you instantly check if your assets meet professional standards (like specific bitrate or codec profiles) without downloading the file and running local diagnostics. - Full asset lifecycle control. You can list files with `list_files`, monitor them via `get_file_info`, and clean up junk using `delete_file`—all managed within a conversational flow. - Guaranteed status tracking. Running a command is never 'fire-and-forget'. The system returns an ID, and you use `get_command_status` to know exactly when the job finishes and where the output file lives. ## How It Works The bottom line is: You get professional media processing power without touching a terminal or managing infrastructure. 1. Subscribe to the Rendi server and supply your API key via your agent's settings. 2. Tell your AI client what you need (e.g., 'Analyze this video' or 'Run a chained command'). 3. The agent invokes the necessary tool(s), handles any required IDs, and provides you with the final status URL. ## Frequently Asked Questions **How do I know if the `run_ffmpeg_command` finished?** You must use the `get_command_status` tool. When you first run a command, it returns an ID. Pass that ID to `get_command_status` to poll for completion and retrieve the final output URL. **Can I convert video to audio using only one tool?** Yes, use the dedicated `convert_video_to_audio` tool. It handles the specific transcoding step of taking a visual file and extracting the clean audio stream for you. **What's the best way to check my media files?** Use `ffprobe`. This tool provides deep, technical metadata—things like resolution, bitrate, and color space—that simple file info tools won't show. It's essential for quality control. **How do I run multiple steps (like resize and convert) at once?** Use `run_chained_ffmpeg_commands`. This tool is designed specifically to execute a sequence of two or more commands, like generating an image thumbnail followed by cropping it. **If my `run_ffmpeg_command` fails due to bad input, where do I find the error logs?** The system reports failure codes directly when you poll for status. The full command output usually contains the specific FFmpeg error message or warning. Check the response from the job status call for details on why the process stopped. **How do I clean up old media assets using `delete_file`?** You must provide the exact storage URL of the file you want gone. Calling `delete_file` permanently removes the asset from Rendi's cloud storage. Use `list_files` first to confirm the full path and ID before deletion. **What parameters can I set when running a thumbnail using `generate_thumbnail`?** You control the size, aspect ratio, and source video file in the request. You specify the desired output resolution (e.g., 1280x720) and often provide an offset frame number for accuracy. **How can I verify which files are currently stored using `list_files`?** `list_files` gives you a full directory listing of everything in your Rendi storage. It returns the file name, size (in bytes), and last modified timestamp for every asset. **Can my AI automatically convert a video file into an MP3 audio track using Rendi?** Yes! Use the `run_ffmpeg_command` tool with the conversion parameters (e.g., 'ffmpeg -i input.mp4 output.mp3'). Your agent will execute the command in the cloud and return the result URL instantly. **How do I find my Rendi API Key?** Log in to your Rendi dashboard at rendi.dev, and your unique secret API key will be displayed on the main page or under account settings. **What is the format for chained FFmpeg commands?** Use the `run_chained_ffmpeg_commands` tool and provide an array of strings, where each string is a valid FFmpeg command. Rendi will execute them sequentially in a single processing job.