Rendi MCP for AI. Run media ops (transcoding, analysis) via natural language prompts.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Connect to your AI in seconds.
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.
What your AI can do
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.
Runs a basic FFmpeg command in the cloud; it returns a unique ID you poll to check if the job finished.
Executes multiple, sequential FFmpeg commands—like transcoding and then analyzing metadata—in one API call.
Uses ffprobe to extract deep details from any media file, including codecs, resolutions, and bitrates.
Creates a specific thumbnail image from a source video file using the generate_thumbnail tool.
Allows listing all stored files (list_files) or getting detailed metadata about a specific asset with get_file_info.
Ask an AI about this
Waiting for input…
Rendi MCP Server: 11 Tools for Video Ops
Use these tools to execute single or chained FFmpeg commands, analyze media metadata, generate thumbnails, and manage files in the cloud.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Rendi on VinkiusConvert 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...
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.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The Rendi integration is available immediately — no restart needed.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Rendi, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Rendi. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 11 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Dealing with media assets today means writing and maintaining complex terminal scripts.
Right now, if you need to transcode a video, you're probably SSHing into a worker machine or calling a multi-step API endpoint that requires dozens of parameters: `--codec`, `--bitrate`, `--preset`, `--optimize`, and so on. You have to manage the input file paths, watch the logs scroll by, and manually pipe outputs from one command into the next until it's perfect.
With Rendi, you just tell your agent what you want—for example, 'Take this 4K video and make a high-quality WebM preview for mobile.' The server handles the entire sequence of commands internally, manages temporary storage, and gives you a clean output without you ever needing to write a complex shell script.
Rendi MCP Server: Orchestrate professional media ops from your chat.
The manual pain points disappear. You don't need to worry about writing the correct FFmpeg syntax for every single codec or container type, nor do you have to manually manage temporary storage IDs. The agent wraps all this complexity into simple tool calls like `run_ffmpeg_command`.
This means your AI client acts as a true media engineer. You don't just execute commands; you orchestrate entire professional content pipelines conversationally. It’s that simple.
What your AI can actually do with this
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.
019dd14d-3071-7290-9f86-db097b996d60 
Here's how it actually works
The bottom line is: You get professional media processing power without touching a terminal or managing infrastructure.
Subscribe to the Rendi server and supply your API key via your agent's settings.
Tell your AI client what you need (e.g., 'Analyze this video' or 'Run a chained command').
The agent invokes the necessary tool(s), handles any required IDs, and provides you with the final status URL.
Who is this actually for?
This is for content operations teams, video producers, and backend developers who spend too much time writing shell scripts to process assets. If you're tired of manually checking codecs, resizing files, or running multi-stage transcoding jobs in a local terminal, this server gives your agent the power to handle it all.
Uses run_ffmpeg_command and ffprobe to quickly test new codec parameters or verify asset standards before handing off assets downstream.
Automates the creation of social media previews by chaining commands: generating a thumbnail, then resizing it, all with minimal conversation.
Manages temporary cloud storage files, using list_files and get_file_info to monitor the health of a complex media pipeline run by the agents.
What Changes When You Connect
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.
See it in action
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.
The honest tradeoffs
Treating media ops like simple API calls
Calling run_ffmpeg_command and assuming the output file is immediately available for download. The job runs, but you get an ID, not a file.
Always check status first. After running run_ffmpeg_command, your next step must be to call get_command_status. Only when that tool confirms 'completed' do you proceed with downloading the output URL.
Using multiple requests for one job
Sending separate prompts like, 'Run command A. Now run command B on the result of A.' This is slow and requires manual state tracking.
Use run_chained_ffmpeg_commands. This tool groups sequential operations (like resizing AND converting) into one request, giving you a single ID to track the entire workflow.
Ignoring file cleanup
Running complex jobs repeatedly without tracking temporary files, leading to massive storage costs and clutter.
Use list_files first to audit your current assets. When a job is done, use delete_file immediately on the temp output ID you no longer need.
When It Fits, When It Doesn't
Use Rendi if your core problem involves media transformation: transcoding, resizing, filtering, or analyzing video/audio codecs and metadata. If your workflow requires this kind of heavy lifting (e.g., 'I need to take a source file and make it optimized for Instagram Stories'), this is the right tool.
Do NOT use Rendi if you are dealing with general data CRUD operations (Create, Read, Update, Delete) on non-media structured data. If your job is simply retrieving user names or updating database records, you need a dedicated database API gateway (like PostgreSQL or MongoDB). Rendi exists solely for the media pipeline; it's not a file system manager for everything else.
When in doubt, if your task involves FFmpeg parameters, ffprobe, or any form of codec/format conversion, this server is built for it.
Questions you might have
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.
We've already built the connector for Rendi. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 11 tools are live and waiting.
You're up and running in seconds.
Gemini Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.