# Vaaya MCP server

Pay-per-call agent superpowers: media/video gen, product demos, research, GTM, scraping, compute.

## Links
- Registry page: https://www.getdrio.com/mcp/ai-vaaya-mcp
- Repository: https://github.com/vaaya-ai/vaaya-mcp
- Website: https://vaaya.ai

## Install
- Command: `npx -y @vaaya/mcp`
- Endpoint: https://vaaya.ai/mcp
- Auth: Not captured

## Setup notes
- Package: Npm @vaaya/mcp v0.3.3
- Remote endpoint: https://vaaya.ai/mcp

## Tools
- vaaya_test_connection (Test Vaaya Connection) - Round-trip ping that confirms the agent → Vaaya connection and whether the user is linked. Returns { ok:true, userId, scope, version, server_time } when linked, or { ok:false, needs_auth:true, verification_uri, signup_uri, instructions } when not linked yet — relay that to the user so they can connect (and sign up if new). Endpoint: https://vaaya.ai/mcp
- vaaya_onboard (Get Onboarding Instructions) - Public onboarding hint for an agent whose user isn't linked to Vaaya yet. Returns where the human should go to connect (and sign up if new). Call this when vaaya_test_connection reports needs_auth, or any tool returns unauthorized, then relay the instructions to the user. Endpoint: https://vaaya.ai/mcp
- vaaya_account (Show Connected Account & Balance) - Show which Vaaya account this connection is linked to and its money state. Returns { email, name, user_id, connected_client, scopes, balance_cents, premium_allowance, credits_url, switch_account }. Call it whenever the user asks "which account is connected", "what's my balance", "how much premium/media credit is left", or "how do I switch accounts" — and relay the answer. `premium_allowance` is the gated free-tier ledger for premium services (media generation, enrichment, compute, scraping): it is SEPARATE from wallet balance, and only credit-pack purchases raise it. Endpoint: https://vaaya.ai/mcp
- vaaya_logout (Disconnect / Switch Vaaya Account) - Disconnect this client from the current Vaaya account: revokes this connection's authorization server-side, so every later call fails with 401 until the user reconnects. Call it when the user asks to log out, sign out, disconnect, or switch Vaaya accounts — then relay the returned switch steps VERBATIM (the browser sign-out step is what actually enables switching accounts). Endpoint: https://vaaya.ai/mcp
- consult (Consult Vaaya — Plan Any Capability) - Vaaya's consultant. Describe ANY external capability you or the user might want — generate an image/video, search or scrape the web, run code in a sandbox, send/receive email, enrich a contact — and it helps figure out the best way, teaching the user what Vaaya can do. It is CONVERSATIONAL and remembers prior turns. It returns: mode='converse' (a reply to RELAY to the user verbatim — questions, options, ideas; get the user's response and call consult again with it, so the conversation continues), mode='call' (an ordered list of calls to run via `use`, with a message explaining the preferred choice + alternatives + why; multi-step results may contain placeholders like '<from step 1: sandbox_id>' — run earlier steps first and substitute), or mode='unsupported'. Every reply includes `suggestions` (2-3 things to do next) — surface these to the user. AFTER you run a `call` result's calls via `use`, call consult ONE more time with a short note on the outcome (what was produced / any failures) — it returns result-aware, Vaaya-grounded next steps to offer the user (the `call` result's `after_running` field reminds you). Call consult whenever you hit a capability gap or the user wants to know what's possible. It does NOT execute or bill — you run returned calls via `use`. ALWAYS show the user consult's `message` and `suggestions` and let them steer. Endpoint: https://vaaya.ai/mcp
- use (Execute a Paid Service Call) - Execute a single call that `consult` handed you, and bill on success. Used for any external capability (image/video/audio generation, web search, scraping, email, document parsing, code sandbox, browser automation, embeddings, etc.). The server validates params against a registered schema and proxies to the upstream — you never pass URLs or API keys. Always get the exact (service, action, params, max_cost_cents) from `consult` first — don't guess them. Endpoint: https://vaaya.ai/mcp
- result (Poll an Async Job) - Fetch the status + output of an async job started by `use` (e.g. a video render). Pass the `job_id` that `use` returned with `{ async: true }`. Returns `{ status, result?, progress?, charged_cents }`: `running` (still working — when the job reports it, `progress` carries `{ phase, percent, rendered_frames, total_frames, eta_sec }` and `hint` is a one-line summary like "rendering 42% (380/900 frames, ~120s left)", so you can tell real progress from a hang; wait a bit and call again), `succeeded` (`result` holds the output, e.g. the video URL; the call is charged now), or `failed`/`cancelled` (no charge; on `failed`, read `error` AND `hint` — `hint` carries the service's usage notes, which usually explain how to fix the call). Safe to call repeatedly — it never starts new work or double-charges. ALWAYS use this to retrieve an async result instead of re-running `use` (re-running starts a new paid job). Endpoint: https://vaaya.ai/mcp
- session (Run Code in a Sandbox Session) - Run a command or code in an open E2B sandbox session (started by `use` with action `create_session`, which returns a `session_id`). Pass `session_id` plus either `command` (a shell command) or `code` (+ optional `language`: python/javascript/bash). Returns stdout/stderr/exit_code (or the code result). The sandbox stays alive — and billed per second of uptime — until you `close` it; re-running reuses the SAME box, so filesystem + process state persist between calls. ALWAYS `close` when done. Endpoint: https://vaaya.ai/mcp
- close (Close a Sandbox Session) - Close an E2B sandbox session and stop its billing. Pass the `session_id`. Captures the final metered uptime cost and releases the hold. ALWAYS call this when finished with a session — an open session keeps billing per second of uptime. Safe to call repeatedly (idempotent). Endpoint: https://vaaya.ai/mcp
- llm (Ask Another LLM) - Ask a DIFFERENT LLM a question and get its answer, billed per token from the Vaaya wallet (model cost + 3%, usually a fraction of a cent). Use it to get a second opinion from a rival model, cross-check an answer, summarize a huge blob cheaply, or query a specific model the user names (Kimi, GPT, Gemini, Claude, DeepSeek, and 300+ more). `model` accepts 'auto' (default: short prompts go cheap, long go mid), 'cheap' | 'mid' | 'best' tiers, or any exact OpenRouter slug like 'moonshotai/kimi-k3'. Typical costs: cheap tier well under 0.1 cents, best tier 1-3 cents per call. Not for the conversation you are already having — it is a one-shot ask to another model. Endpoint: https://vaaya.ai/mcp

## Resources
Not captured

## Prompts
Not captured

## Metadata
- Owner: ai.vaaya
- Version: 0.3.3
- Runtime: Npm
- Transports: STDIO, HTTP
- License: Not captured
- Language: Not captured
- Stars: Not captured
- Updated: Jul 7, 2026
- Source: https://registry.modelcontextprotocol.io