4,500+ servers built on MCP Fusion
Vinkius

Theta MCP. Manage AI Deployments and Video Workflows.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Theta MCP on Cursor AI Code Editor MCP Client Theta MCP on Claude Desktop App MCP Integration Theta MCP on OpenAI Agents SDK MCP Compatible Theta MCP on Visual Studio Code MCP Extension Client Theta MCP on GitHub Copilot AI Agent MCP Integration Theta MCP on Google Gemini AI MCP Integration Theta MCP on Lovable AI Development MCP Client Theta MCP on Mistral AI Agents MCP Compatible Theta MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

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 your AI agents can do

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.

+ 27 more capabilities included
Manage AI Model Deployments

Create, list, start, or delete full-stack AI deployments on the EdgeCloud.

Query Blockchain Status

Get specific block details by hash or height, and check pending transactions in the mempool.

Send Transactions

Lock/unlock local accounts and submit signed Theta/TFuel transactions synchronously or asynchronously.

Process Video Assets

Generate secure upload links, transcode raw videos, and manage live streaming objects.

List Network Resources

Check available VM resource types or list all existing AI deployments in a project.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

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.

ai019e5d5f

ai create deployment

Launches a new AI model or Jupyter Notebook environment on EdgeCloud.

ai019e5d5f

ai delete deployment

Terminates an existing AI deployment, cleaning up resources.

ai019e5d5f

ai list deployments

Retrieves a list of all current and past deployments associated with the project.

ai019e5d5f

ai list standard templates

Shows the built-in, pre-configured AI templates available for use.

ai019e5d5f

ai list vm resources

Lists all machine types and GPU resources currently available on the EdgeCloud.

ai019e5d5f

ai start deployment

Restarts a GPU Node that has been stopped, bringing it back online for work.

ai019e5d5f

ai stop deployment

Shuts down a running GPU Node to save costs and free up resources.

cli019e5d5f

cli list keys

Outputs all local account addresses managed by the Theta CLI integration.

cli019e5d5f

cli lock key

Locks local accounts, preventing them from sending transactions until explicitly unlocked.

cli019e5d5f

cli new key

Creates a new, encrypted account locally for secure key management.

cli019e5d5f

cli send

Sends Theta or TFuel tokens from an active local account.

cli019e5d5f

cli unlock key

Unlocks a specified local account, allowing it to send transactions again.

rpc019e5d5f

rpc broadcast raw transaction

Submits a signed transaction data payload to the network immediately and waits for confirmation.

rpc019e5d5f

rpc broadcast raw transaction async

Submits a signed transaction data payload asynchronously, allowing your agent to continue other work.

rpc019e5d5f

rpc call smart contract

Simulates executing code within a smart contract environment locally before deploying it on-chain.

rpc019e5d5f

rpc get account

Fetches detailed information and balance status for a specific Theta account address.

rpc019e5d5f

rpc get block

Retrieves the complete details of a block using its unique hash identifier.

rpc019e5d5f

rpc get block by height

Gets finalized details for any block at a specific, given height number on the chain.

rpc019e5d5f

rpc get pending transactions

Checks the mempool to retrieve a list of transactions waiting to be confirmed by miners.

rpc019e5d5f

rpc get transaction

Pulls specific transaction details using its unique hash, confirming what happened.

rpc019e5d5f

rpc get version

Returns the current version number of the Theta blockchain software running on the network.

video019e5d5f

video create livestream

Sets up a new live stream object that tracks video content and metadata.

video019e5d5f

video create upload url

Generates a unique, temporary URL where external clients can upload large video files securely.

video019e5d5f

video get

Retrieves the metadata and status details for a specific video asset or stream.

video019e5d5f

video list

Lists all videos associated with your service account within the Theta media platform.

video019e5d5f

video list ingestors

Provides a list of available Edge Ingestor services that can handle video uploads.

video019e5d5f

video search

Searches the entire video library using specific metadata filters (e.g., date, tags).

video019e5d5f

video select ingestor

Assigns a specific Edge Ingestor service to manage and process an active stream.

video019e5d5f

video transcode

Processes raw video files, converting them into various formats (e.g., 1080p MP4) for distribution.

video019e5d5f

video unselect ingestor

Releases an assigned Edge Ingestor service from a stream, freeing up capacity.

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
Start building

Make Your AI Do More

Start with Theta, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,700+ 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

What you can do with this MCP connector

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.

How Theta MCP Works

  1. 1 First, subscribe to the Theta server and give your agent the necessary credentials (RPC URL, EdgeCloud/Video API keys).
  2. 2 Then, tell your AI client what you need—for example: 'List all available VM resources for a new deployment.'
  3. 3 The agent executes the relevant tool (ai_list_vm_resources), gets the data back, and reports it to you in plain English.

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.

Who Is Theta MCP 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.

Blockchain Developer

You use rpc_get_block to verify transaction history or run smart contract simulations using rpc_call_smart_contract before writing final code.

AI/ML Engineer

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.

Content Operations Manager

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.

Real-World Use Cases

01

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.

02

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.

03

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.

04

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 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.

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

How we secure it →

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 server provides 30 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

ai_create_deployment ai_delete_deployment ai_list_deployments ai_list_standard_templates ai_list_vm_resources ai_start_deployment ai_stop_deployment cli_list_keys cli_lock_key cli_new_key cli_send cli_unlock_key rpc_broadcast_raw_transaction rpc_broadcast_raw_transaction_async rpc_call_smart_contract rpc_get_account rpc_get_block rpc_get_block_by_height rpc_get_pending_transactions rpc_get_transaction rpc_get_version video_create_livestream video_create_upload_url video_get video_list video_list_ingestors video_search video_select_ingestor video_transcode video_unselect_ingestor

Managing decentralized resources shouldn't require jumping between five different dashboards.

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.

Common Questions About Theta MCP

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.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 30 tools

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.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

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.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.