Theta MCP for AI. Manage AI Deployments and Video Workflows.
Works with every AI agent you already use
…and any MCP-compatible client








How this MCP server connects to your AI agent
Theta MCP Server lets your agent manage decentralized infrastructure directly. You can query blockchain data—check account balances with `rpc_get_account` or fetch block hashes using `rpc_get_block`.
It also handles EdgeCloud AI deployment (create, stop, list) and manages the full video pipeline: generating URLs via `video_create_upload_url`, transcoding assets, and orchestrating livestreams.
What AI agents can do with Theta Automation
Ai create deployment
Launches a new AI model or Jupyter Notebook environment on EdgeCloud.
Ai delete deployment
Terminates an existing AI deployment, cleaning up resources.
Ai list deployments
Retrieves a list of all current and past deployments associated with the project.
Create, list, start, or delete full-stack AI deployments on the EdgeCloud.
Get specific block details by hash or height, and check pending transactions in the mempool.
Lock/unlock local accounts and submit signed Theta/TFuel transactions synchronously or asynchronously.
Generate secure upload links, transcode raw videos, and manage live streaming objects.
Check available VM resource types or list all existing AI deployments in a project.
Ask an AI about this
Waiting for input…
What AI agents can do with Theta MCP Server: 29 Tools for Web3 Infrastructure
These tools let your AI client perform everything from querying block hashes to managing GPU node lifecycles and transcribing media assets.
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 Theta on VinkiusAi Create Deployment
Launches a new AI model or Jupyter Notebook environment on EdgeCloud.
Ai Delete Deployment
Terminates an existing AI deployment, cleaning up resources.
Ai List Deployments
Retrieves a list of all current and past deployments associated with the project.
Ai List Standard Templates
Shows the built-in, pre-configured AI templates available for use.
Ai List Vm Resources
Lists all machine types and GPU resources currently available on the EdgeCloud.
Ai Start Deployment
Restarts a GPU Node that has been stopped, bringing it back online for work.
Ai Stop Deployment
Shuts down a running GPU Node to save costs and free up resources.
Cli List Keys
Outputs all local account addresses managed by the Theta CLI integration.
Cli Lock Key
Locks local accounts, preventing them from sending transactions until explicitly...
Cli New Key
Creates a new, encrypted account locally for secure key management.
Cli Send
Sends Theta or TFuel tokens from an active local account.
Cli Unlock Key
Unlocks a specified local account, allowing it to send transactions again.
Rpc Get Account
Fetches detailed information and balance status for a specific Theta account address.
Rpc Get Block By Height
Gets finalized details for any block at a specific, given height number on the chain.
Rpc Get Block
Retrieves the complete details of a block using its unique hash identifier.
Rpc Broadcast Raw Transaction Async
Submits a signed transaction data payload asynchronously, allowing your agent to...
Rpc Broadcast Raw Transaction
Submits a signed transaction data payload to the network immediately and waits for...
Rpc Call Smart Contract
Simulates executing code within a smart contract environment locally before deploying it on-chain.
Rpc Get Pending Transactions
Checks the mempool to retrieve a list of transactions waiting to be confirmed by miners.
Rpc Get Transaction
Pulls specific transaction details using its unique hash, confirming what happened.
Rpc Get Version
Returns the current version number of the Theta blockchain software running on the...
Video Create Livestream
Sets up a new live stream object that tracks video content and metadata.
Video Create Upload Url
Generates a unique, temporary URL where external clients can upload large video...
Video Get
Retrieves the metadata and status details for a specific video asset or stream.
Video List Ingestors
Provides a list of available Edge Ingestor services that can handle video uploads.
Video List
Lists all videos associated with your service account within the Theta media...
Video Search
Searches the entire video library using specific metadata filters (e.g., date, tags).
Video Select Ingestor
Assigns a specific Edge Ingestor service to manage and process an active stream.
Video Transcode
Processes raw video files, converting them into various formats (e.g., 1080p MP4)...
Video Unselect Ingestor
Releases an assigned Edge Ingestor service from a stream, freeing up capacity.
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.
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 Theta, 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 Theta. 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
Built on the Model Context Protocol (MCP) for 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 30 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Managing decentralized resources shouldn't require jumping between five different dashboards., Solved with Vinkius AI Gateway
Right now, managing infrastructure means logging into a blockchain explorer for transaction history, then switching tabs to the cloud console to check GPU availability, and finally opening a separate media platform dashboard just to initiate transcoding. You spend half your time copying hashes and juggling credentials.
With this MCP server, you tell your agent, 'Check block 25000000 and if it's stable, deploy the new model.' The agent runs `rpc_get_block`, checks its status, then executes `ai_create_deployment`—all in one chat thread. It handles the handoffs.
Theta MCP Server: Orchestrate video and AI deployments from your prompt.
Manually handling a large asset means getting an upload URL, uploading the file via external tools, then manually triggering transcoding with specific parameters. If you mess up any step, the whole pipeline stalls.
Now, you simply ask your agent to 'Prep this video for our stream.' It automatically calls `video_create_upload_url`, waits for the data, runs `video_transcode` into required formats, and sets up the live feed via `video_create_livestream`. Done.
What your AI can actually do with this
This server gives your agent direct command over decentralized infrastructure—everything from managing AI deployments on EdgeCloud to running full video pipelines and submitting blockchain transactions. You don't need a dedicated terminal; your agent handles it all.
AI Model Deployments:
Your agent can manage the entire lifecycle of AI models using tools like ai_list_standard_templates to see what built-in templates are ready for use, or ai_list_deployments to check every current and past deployment associated with your project. Need a new environment? You'll launch it by calling ai_create_deployment for a fresh AI model or Jupyter Notebook setup.
When you're done with the compute cycle, you can shut down resources using ai_stop_deployment to save cash, or delete the entire deployment via ai_delete_deployment. If a GPU Node gets stopped, you can bring it back online and ready for work by running ai_start_deployment; you'll also check available hardware types using ai_list_vm_resources.
Blockchain Operations:
Your agent lets you read the whole ledger. You can fetch detailed status and balances for any specific Theta account address with rpc_get_account. To track network movement, you can get finalized details for any block at a specific height using rpc_get_block_by_height, or pull complete data using a unique hash identifier via rpc_get_block.
For real-time monitoring, check the mempool contents to see all transactions waiting confirmation with rpc_get_pending_transactions, and drill down on specific events by getting transaction details with rpc_get_transaction using its unique hash. The network also gives you basic info like the current version number of the blockchain software running via rpc_get_version.
For sending money or data, your agent handles transactions securely. You'll list all local account addresses managed by the Theta CLI integration with cli_list_keys and create a new, encrypted key locally using cli_new_key. If you need to pause an account for safety, use cli_lock_key; when it’s clear everything is safe, run cli_unlock_key on that specific account.
You can send both Theta or TFuel tokens from an active local account with cli_send. For broadcasting raw transactions, you've got two options: submit a signed data payload immediately and wait for confirmation using rpc_broadcast_raw_transaction, or use rpc_broadcast_raw_transaction_async to send the data without forcing your agent to wait.
Key Management:
Beyond just sending tokens, you manage key security directly. You'll list all local account addresses with cli_list_keys; create a new encrypted account using cli_new_key; lock an existing account with cli_lock_key until it's safe to proceed; and unlock that account again when transactions are ready via cli_unlock_key.
Video Media Pipeline:
Your agent manages the entire media workflow. You can start by listing all videos tied to your service account using video_list, or search your entire library for specific assets based on metadata like date or tags, which you do with video_search. Before a big upload, generate a unique, temporary URL using video_create_upload_url; this is where external clients can securely drop large video files.
To process raw media, call video_transcode to convert files into multiple formats—say, 1080p MP4—for distribution. For live content, you'll first set up a new stream object using video_create_livestream, then assign an Edge Ingestor service using video_select_ingestor; remember to release that capacity later with video_unselect_ingestor. You can retrieve the metadata and status for any video asset or stream by running video_get, while checking available processing services with video_list_ingestors.
019e5d5f-786e-70a5-ab10-324a61e264b1 Here's how it actually works
The bottom line is that your AI client uses these tools as functions it can call directly, letting you interact with complex systems like blockchain networks without writing boilerplate code.
First, subscribe to the Theta server and give your agent the necessary credentials (RPC URL, EdgeCloud/Video API keys).
Then, tell your AI client what you need—for example: 'List all available VM resources for a new deployment.'
The agent executes the relevant tool (ai_list_vm_resources), gets the data back, and reports it to you in plain English.
Who is this actually for?
This is for the Web3 developer who needs to integrate core infrastructure tasks—like checking block hashes or sending tokens—into an application workflow. It's also for AI engineers scaling models on decentralized hardware, and content platform ops staff managing high-volume video ingestion.
You use rpc_get_block to verify transaction history or run smart contract simulations using rpc_call_smart_contract before writing final code.
You automate the deployment cycle. You check available resources with ai_list_vm_resources, then use ai_create_deployment to spin up a new model instance on EdgeCloud.
You manage video pipelines. When a client uploads footage, you automatically call video_create_upload_url, then trigger video_transcode and finally create the livestream object via video_create_livestream.
What Changes When You Connect
Blockchain queries are instant. Instead of opening a separate RPC client, you use rpc_get_block or rpc_get_pending_transactions directly in conversation to get real-time network status.
AI resource scaling is controlled via code. You can list templates with ai_list_standard_templates and then immediately launch a new environment using ai_create_deployment, all without leaving your agent's chat interface.
Video workflows become fully automated. When content arrives, the agent uses video_create_upload_url for ingestion, followed by video_transcode to get it ready for any platform.
Key management is secure and simple. You can list local keys with cli_list_keys and use cli_unlock_key when you're ready to execute a financial transaction via cli_send.
Node state changes are direct commands. Need to pause costs? Use ai_stop_deployment. Need it back? Call ai_start_deployment. It’s simple, immediate control over your GPU resources.
See it in action
Checking a Smart Contract Before Deployment
A dev finds an old contract address. Instead of guessing if the code is valid or if the gas limits are right, they tell their agent to run rpc_call_smart_contract with sample inputs. The agent simulates the execution locally, giving them immediate feedback on expected state changes before they commit to a live deployment.
Handling Live Video Ingestion
A content team is going live. They don't want manual steps. Their agent first calls video_create_upload_url for the raw stream, then uses video_select_ingestor to assign a worker service, and finally monitors status with video_get. The entire process runs without human intervention.
Monitoring Network Health Post-Incident
After an outage, the ops engineer needs to know what's stuck. They ask their agent for a list of pending transactions (rpc_get_pending_transactions) and then cross-reference those hashes by calling rpc_get_transaction until they find the missing data point.
Quickly Scaling AI Testing
A team needs to test a new model on high-end hardware. The agent first checks capacity using ai_list_vm_resources. Once confirmed, it runs ai_create_deployment for the required GPU size, then waits until the node is ready to start testing.
The honest tradeoffs
Treating RPC calls like a database lookup
A user tries to 'get all transactions' by just calling rpc_get_transaction without parameters, assuming the tool knows what they mean. This fails because it requires a specific transaction hash.
To find recent activity, start by listing pending items using rpc_get_pending_transactions. Then, pick a hash from that list and call rpc_get_transaction(hash) to get the full details you need.
Forgetting key state management
A user tries to send tokens (cli_send) but hasn't unlocked the account first, resulting in an 'Account Locked' error and forcing them to start over.
Always check the status. If you suspect a lock, run cli_list_keys first. Then use cli_unlock_key(address) before attempting any transfer with cli_send.
Assuming deployment status is automatic
A user calls ai_create_deployment and immediately asks for the model output, but the node hasn't finished spinning up or allocating resources yet. The agent gives an error because the resource isn't ready.
After running ai_create_deployment, always follow up with ai_list_deployments to verify its status before sending it a command like 'run model inference'.
When It Fits, When It Doesn't
Use this Theta MCP Server if your process involves coordinating three distinct, high-complexity domains: decentralized finance/blockchain (RPC/CLI), cloud infrastructure management (AI Deployment), and media processing (Video). You need the agent to switch between these protocols fluidly. Don't use it if you only need one function—for example, if all you want is basic video searching, a dedicated media API tool will be simpler. If your goal is purely blockchain analysis without needing deployment orchestration, stick to pure RPC clients. This server handles cross-domain state changes and resource allocation.
Questions you might have
How do I check the current network health using rpc_get_version? +
You run rpc_get_version to get the exact software version. This is useful for ensuring your client tools are compatible with what's running on the Theta blockchain.
What’s the difference between cli_send and rpc_broadcast_raw_transaction? +
cli_send handles the full process: it checks if your key is unlocked (cli_unlock_key) and then sends the tokens for you. rpc_broadcast_raw_transaction requires you to manually prepare a signed transaction payload.
How can I list available GPU resources with ai_list_vm_resources? +
Just prompt your agent to 'List VM resources.' The tool runs ai_list_vm_resources and returns specific hardware details, like the NVIDIA T4 type and available RAM/vCPU counts.
Can I search videos using video_search? +
Yes. You pass metadata filters—like a date range or a specific tag—to video_search. It finds matching assets across your entire service account's library instantly.
How do I manage key security after running cli_new_key? +
The system generates a new encrypted account and returns your private seed phrase. You must copy this phrase immediately and store it offline in a secure location. Never share or input this phrase into an online tool.
What is the proper sequence when I use video_create_upload_url followed by video_transcode? +
First, you generate the upload URL and push your raw asset to that endpoint. Once the ingestion confirms receipt, you call video_transcode with the resulting video ID. Transcoding then processes the file into multiple formats.
If I run ai_stop_deployment on a node that is already stopped, will it cause an error? +
No. The tool checks the current state first and simply confirms the deployment is inactive. You can safely use ai_stop_deployment regardless of the node's current status to ensure the command executes cleanly.
How do I check if a signed transaction is pending confirmation using rpc_get_pending_transactions? +
This tool returns a list of all transactions currently in the mempool. You can filter this data by your specific account address or transaction hash to see if it's waiting for block inclusion.
How can I check the balance and sequence of a specific Theta wallet? +
Use the rpc_get_account tool by providing the wallet address (0x...). The agent will return the coin balances and the current sequence number for that account.
Can I manage AI model deployments on Theta EdgeCloud? +
Yes. You can use ai_list_deployments to see active ones, and ai_create_deployment or ai_stop_deployment to control your AI infrastructure resources.
How do I search for existing video assets in my Theta library? +
Simply use the video_search tool. You can provide a query string to filter through your uploaded and transcoded video content.
We've already built the connector for Theta. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 30 tools are live and waiting.
You're up and running in seconds.
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.