Quo MCP connector for AI agents

Tools your business phone agent reaches for on Quo, scoped per user.

CALL ANY TOOL

15 tools for your business phone: fetch messages, missed calls, and call transcripts, manage contacts and tasks, and send one-to-one, group, or bulk texts.

quomcp_create_contact

Create contact

Create a new contact in the Quo workspace. Returns the new contact ID and a compact pipe-separated row that can be chained into `update-contact` or `get-contact`. Only `firstName` is required; all other fields are optional.

Parameters

Name

Type

Required

Description

firstName

string

Required

Contact's first name (required)

company

string

Optional

Contact's company name

string

Optional

Contact's email address, RFC-5322 format (e.g., 'jane@example.com')

lastName

string

Optional

Contact's last name

phoneNumber

string

Optional

Contact's phone number. Format as E.164 before sending (e.g. '+15551234567', '+447911123456'). International numbers are supported.

role

string

Optional

Contact's role or title

quomcp_create_task

Create task

quomcp_fetch_call_transcripts

Fetch call transcripts

Fetch call transcripts for a Quo inbox. Requires the Quo Business plan and calls where transcription was enabled. Optionally filter by `userId` to return only calls handled by a specific team member (use `list-users` to look up user IDs). Each result row is `id | participant | direction | status | createdAt | duration | conversationId`; the leading `id` is the call's activity ID (AC…), pass it to `create-task` as `activityId` to link a follow-up task to that specific call. When `participantPhoneNumber` is omitted, the tool aggregates across participants discovered from conversations, and the trailing `conversationId` (CN…) is populated for thread-level task linking. Set `createdAfter` to bound the window, the tool filters conversation discovery by that time server-side, so a call whose conversation is old but had recent activity is still found. Single-participant queries leave the `conversationId` column blank since the per-call `activityId` is already a precise link target. To page through additional results, use `participantPhoneNumber` + `pageToken` for a single participant, or `conversationPageToken` if you hit the conversation-discovery safety cap. Timezone: `createdAfter`/`createdBefore` are treated as UTC, pass ISO 8601 with a 'Z' suffix or an explicit offset, and every timestamp in results is UTC. When the user asks in relative terms (e.g. 'yesterday', 'this week'), scope the window to THEIR local timezone and convert to the matching UTC instants before calling; if you don't know their timezone, ask. Present returned times in the user's local timezone. When showing a phone number to the user, render it as a click-to-call link, e.g. [(555) 555-5555](tel:+15555555555). Pass the bare E.164 value (not a tel: URI) into tool parameters.

Parameters

Name

Type

Required

Description

inboxPhoneNumber

string

Required

Your Quo inbox number or phone-number ID to find transcripts for (E.164 like '+15555555555', or a PN... ID). Use list-inboxes to discover available numbers.

conversationPageToken

string

Optional

Optional: token to fetch older conversations when doing multi-participant discovery. Use this if the response shows 'More conversations available'. Only used when participantPhoneNumber is NOT specified.

createdAfter

string

Optional

Optional: filter calls created after this ISO 8601 datetime with offset (e.g. '2024-01-01T00:00:00Z').

createdBefore

string

Optional

Optional: filter calls created before this ISO 8601 datetime with offset (e.g. '2024-01-01T00:00:00Z').

maxResults

number

Optional

Maximum number of calls to fetch transcripts for (default: 100, max: 100 when using pagination). Default: `100`.

pageToken

string

Optional

Optional: token from previous response to fetch the next page of results. Can only be used with participantPhoneNumber (single-participant queries). Not supported when fetching across all participants.

participantPhoneNumber

string

Optional

Optional: specific participant phone number to filter conversations (E.164 format). REQUIRED when using pageToken for pagination.

userId

string

Optional

Optional: filter calls by a specific team member's user ID (US… format). When provided, returns only calls handled by that user. Use `list-users` to look up user IDs.

quomcp_fetch_messages

Fetch messages

Fetch message history for a Quo inbox. Two modes: • Single contact (`participantPhoneNumber` set), DEPTH: returns that contact's full message history, most-recent-first, with pagination via `pageToken` (up to 100 per page). Each message is `id | participant | direction | timestamp` followed by the text; the leading `id` is the message's activity ID (AC…), pass it to `create-task` as `activityId`. A message with MMS attachments is followed by one indented `media: <mime-type> <url>` line per attachment; text-only messages have none. A message may carry both text and attachments, when it does, the body is the text and the media lines follow it. ALWAYS pass the attachment URL through to the user as a clickable markdown link (e.g. [image/png](https://example.com/image.png)); stating that an attachment exists without giving its URL is not useful, since the user cannot open a link they were not shown. Never shorten, truncate, or omit the URL. When an attachment arrives with no accompanying text the body shows `(no text)`; describe that to the user as a photo or file, not as an empty message. • Whole inbox (`participantPhoneNumber` omitted), BREADTH: returns the most-recent messages for EVERY contact active in the window, grouped by contact (up to 10 messages each, up to 50 contacts), so a daily-summary query never silently drops a contact. Each contact's conversation ID (CN…) is on its header for `create-task` linking. A contact with more than 10 in-window messages is flagged (`[more than 10 …]`), re-query that contact with `participantPhoneNumber` for the full thread. If more than 50 contacts were active, an `[incomplete: …]` line reports how many were left out; narrow the date range or query specific contacts. `maxResults` is ignored in this mode. Set `createdAfter` to bound the window, the tool filters conversation discovery by that time server-side, so a contact with a recent message is found even when their conversation is old. Without `createdAfter`, discovery falls back to the most recent conversations. Timezone: `createdAfter`/`createdBefore` are treated as UTC, pass ISO 8601 with a 'Z' suffix or an explicit offset, and every timestamp in results is UTC. When the user asks in relative terms (e.g. 'yesterday', 'this week'), scope the window to THEIR local timezone and convert to the matching UTC instants before calling; if you don't know their timezone, ask. Present returned times in the user's local timezone. When showing a phone number to the user, render it as a click-to-call link, e.g. [(555) 555-5555](tel:+15555555555). Pass the bare E.164 value (not a tel: URI) into tool parameters.

Parameters

Name

Type

Required

Description

inboxPhoneNumber

string

Required

Your Quo inbox number or phone-number ID to fetch messages for (E.164 like '+15555555555', or a PN... ID). Use list-inboxes to discover available numbers.

conversationPageToken

string

Optional

createdAfter

string

Optional

Optional: filter messages created after this ISO 8601 datetime with offset (e.g. '2024-01-01T00:00:00Z').

createdBefore

string

Optional

Optional: filter messages created before this ISO 8601 datetime with offset (e.g. '2024-01-01T00:00:00Z').

maxResults

number

Optional

Maximum number of messages to fetch (default: 100, max: 100). Only applies to single-contact queries (participantPhoneNumber set). Ignored for whole-inbox queries, which return up to 10 messages per contact across up to 50 contacts. Default: `100`.

pageToken

string

Optional

Optional: token from previous response to fetch the next page of results. Can only be used with participantPhoneNumber (single-participant queries). For multi-participant aggregation, pagination is not supported.

participantPhoneNumber

string

Optional

Optional: specific participant phone number to filter conversations (E.164 format). REQUIRED when using pageToken for pagination.

userId

string

Optional

Optional: filter to messages sent by a specific team member's user ID (US… format). Incoming messages are excluded when this filter is set, since the API does not associate them with a sender user ID. Use `list-users` to look up user IDs.

quomcp_fetch_missed_calls

Fetch missed calls

Fetch missed incoming calls for a Quo inbox, each enriched with the voicemail the caller left (transcript + recording URL) when there is one. Only returns incoming calls whose status is 'missed', 'no-answer', or 'abandoned', this filter is fixed and cannot be changed or broadened. Use it for questions like 'what calls did I miss yesterday?' or 'any voicemails this week?'. Each result is a row `id | status | direction | participants | createdAt | duration | conversationId`; the leading `id` is the call's activity ID (AC…), pass it to `create-task` as `activityId` to link a follow-up task to that specific call. The trailing `conversationId` (CN…) is for thread-level task linking and is populated only when discovering across multiple participants (single-participant queries leave it blank since the per-call `activityId` is already precise). Rows whose call has a voicemail are followed by an indented voicemail block (status, duration, recordingUrl, transcript). Voicemails are processed asynchronously, a voicemail with status 'in-progress' has null duration/transcript/recordingUrl, so retry in a few seconds. Missed calls where the caller hung up without leaving a message are still listed, just marked '(no voicemail)'. When `participantPhoneNumber` is omitted, the tool aggregates calls across all participants active in your `createdAfter` window, the tool filters conversation discovery by that time server-side, so a missed call whose conversation is old but had recent activity is still found. Without `createdAfter`, discovery falls back to the most recent conversations. For exhaustive single-contact pulls, use `participantPhoneNumber` + `pageToken`; if you hit the conversation-discovery safety cap, use `conversationPageToken` to continue. Timezone: `createdAfter`/`createdBefore` are treated as UTC, pass ISO 8601 with a 'Z' suffix or an explicit offset, and every timestamp in results is UTC. When the user asks in relative terms (e.g. 'yesterday', 'this week'), scope the window to THEIR local timezone and convert to the matching UTC instants before calling; if you don't know their timezone, ask. Present returned times in the user's local timezone. When showing a phone number to the user, render it as a click-to-call link, e.g. [(555) 555-5555](tel:+15555555555). Pass the bare E.164 value (not a tel: URI) into tool parameters.

Parameters

Name

Type

Required

Description

inboxPhoneNumber

string

Required

Your Quo inbox number or phone-number ID to list calls for (E.164 like '+15555555555', or a PN... ID). Use list-inboxes to discover available numbers.

conversationPageToken

string

Optional

createdAfter

string

Optional

Optional: filter calls created after this ISO 8601 datetime with offset (e.g. '2026-05-19T00:00:00Z').

createdBefore

string

Optional

Optional: filter calls created before this ISO 8601 datetime with offset (e.g. '2026-05-20T00:00:00Z').

maxResults

number

Optional

Maximum number of calls to return after filtering (default: 100, max: 100 when using pagination). Default: `100`.

pageToken

string

Optional

participantPhoneNumber

string

Optional

Optional: specific other-party phone number to filter calls (E.164 format). REQUIRED when using pageToken for pagination.

quomcp_get_contact

Get contact

quomcp_list_contacts

List contacts

quomcp_list_inboxes

List inboxes

quomcp_list_tasks

List tasks

quomcp_list_users

List users

quomcp_send_bulk_messages

Send bulk messages

Send SMS to up to 40 recipients as SEPARATE individual (1:1) messages, a broadcast. Two modes: for the SAME text to everyone, pass `to` (2-40 numbers) + `content`; to personalize per recipient, pass `messages` as [{to, content}] instead. Provide one mode or the other, never both. Prefer `to` + `content` when the text is identical, it guarantees everyone receives exactly the same message. Each recipient gets their own private thread and does NOT see the other recipients; replies come back individually. Use this for announcements or blasts. This is different from send-group-message, which puts everyone in ONE shared thread that exposes their numbers to each other, use that only when recipients should see one another. For a single recipient use send-message. Sends cannot be undone. The `from` number must belong to the user's Quo workspace, use `list-inboxes` to discover available numbers. Recipients must be valid phone numbers in E.164 format (international supported).

Parameters

Name

Type

Required

Description

from

string

Required

Your Quo number to send from. Accepts E.164 (e.g. '+15551234567'), a phone-number ID, or a recognizable local format. Must belong to your Quo workspace, use list-inboxes to discover available numbers.

content

string

Optional

SAME-MESSAGE mode. The single message body, sent identically to every recipient in `to`. REQUIRED together with `to`, unless you are using `messages` instead. Omit this entirely when using `messages`, supplying both modes is an error.

messages

array

Optional

PERSONALIZED mode. One entry per recipient (2-40), each with its own `to` and `content`, e.g. [{"to": "+15551234567", "content": "Hi John, you're confirmed for 2pm"}, {"to": "+15559876543", "content": "Hi Sarah, you're confirmed for 3pm"}]. REQUIRED unless you are using `to` + `content` instead. Use this ONLY when the text differs per recipient; if everyone gets the same text, use `to` + `content`, which guarantees an identical message. Each recipient still receives a SEPARATE private message and cannot see the others. A phone number may appear only once. Omit this entirely when using `to` + `content`, supplying both modes is an error.

array

Optional

SAME-MESSAGE mode. The recipients' phone numbers (2-40), each in E.164 format (e.g. '+15551234567'). REQUIRED together with `content`, unless you are using `messages` instead. Each recipient receives a SEPARATE private message and cannot see the others. Omit this entirely when using `messages`, supplying both modes is an error. For one shared group thread, use send-group-message instead.

quomcp_send_group_message

Send group message

quomcp_send_message

Send message

quomcp_update_contact

Update contact

quomcp_update_task

Update task

Build your Agent

Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.

import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// Quo MCP tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["quomcp"], toolNames: [
    "quomcp_list_inboxes",
    "quomcp_fetch_missed_calls",
    "quomcp_send_message"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Show today's missed calls on the support line" }] });

import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["quomcp"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Show today's missed calls on the support line" }],
  tools,
});

// Execute the tool call with the user's vaulted Quo token
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");

import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["quomcp"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Show today's missed calls on the support line" }],
  tools,
});

// Tool call runs with the user's vaulted Quo token
await sk.tools.executeTool(msg.content, "user_123");

import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["quomcp"] }, pageSize: 100,
});

const agent = new Agent({
  name: "phone_agent",
  model: "gemini-2.5-pro",
  instruction: "Quo MCP tools scoped to this user",
  tools,
});

await agent.run("Show today's missed calls on the support line");

Try these prompts

Copy any prompt into your agent. Each maps directly to a Quo MCP tool. Click to copy, paste into your agent, done.

Calls and messages

Copy the prompt

Copied

Show today's missed calls on the support line with voicemails.

Copy the prompt

Copied

Fetch the message history with this customer's number.

Copy the prompt

Copied

Pull call transcripts from the sales inbox handled by Dana this week.

Contacts

Copy the prompt

Copied

Create a contact for Jordan Lee at Acme, role Head of Ops.

Copy the prompt

Copied

Update this contact's email and company.

Copy the prompt

Copied

List the first 50 contacts in the workspace.

Texts and tasks

Copy the prompt

Copied

Text this customer that their order shipped.

Copy the prompt

Copied

Create a task to call back this missed caller tomorrow.

Copy the prompt

Copied

List tasks in the workspace and flag the overdue ones.

SEE HOW AUTH WORKS

Each user signs in to Quo once; Scalekit stores and refreshes their tokens. Tokens stay vaulted, every call is scope checked, and every action is logged.

Authorize

Your user connects

Quo MCP

once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access

Who:

user ‘A’

when:

Once per user

access:

Limited to user

Store

Their

Quo MCP

token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection

vault:

encrypted

scope:

per-user

tokens:

auto-refreshed

Resolve

When your agent calls a

Quo MCP

tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs

speed:

~40ms

check:

before every call

seen by:

nobody

Audit

Every

Quo MCP

tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it

history:

90 days

export:

SIEM-ready

logged:

every call

Test other agents

See the same per-user auth pattern across other communication and CRM connectors.

GTM and RevOps Teams

CRM AI agent

Reads the Granola transcript after every call, extracts next steps and updates the HubSpot record, drafts the follow-up in Gmail, and confirms in Slack, all on the rep's own delegated OAuth.

GTM and RevOps Teams

Sales call prep agent

Reads tomorrow's calls from Google Calendar, mines past Granola notes and Attio history for context, and delivers each rep a prep brief in Slack, scoped to the calls that rep actually owns.

Support and Ops Teams

Support triage agent

Fetches new Zendesk tickets, classifies them by type and urgency, searches the Notion knowledge base for an answer, and routes what it cannot resolve to Slack. Every call runs on the support agent's own delegated OAuth.

GTM and RevOps Teams

Outbound prospecting agent

Searches Apollo for prospects matching your ICP, scores and ranks them, drafts personalized outreach in Gmail, and logs every send to Google Sheets. Mail goes out as the rep, not from a shared inbox.

Why Scalekit

Secure your agent's access. Connectors ship in minutes

01.

Shared tokens break per-user analytics

A shared Quo token looks fine in a demo. In production every text sent and call read looks like one service account, and you cannot tell which user triggered it. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.

// shared token
audit → bot_service_account

// scalekit
audit → user_abc ✓

02.

Authentication is not authorization

03.

Multi-tenancy is architectural

04.

Quo today. Ten connectors tomorrow.

“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”

Venu Madhav Kattagoni

Head of Engineering / Von

FAQs

Frequently Asked Questions

Does the agent access Quo as the user or as a shared key?

As the user. Each user signs in to Quo once, and Scalekit stores and refreshes their tokens. Audit logs attribute every text and call read to that user, not a shared service account.

Where is the Quo OAuth token stored?

In Scalekit's managed AES-256 token vault, namespaced per tenant. Refresh is automatic. Revocation is a single dashboard action. Credentials never appear in prompts, logs, or LLM context.

Can I limit what the agent does in Quo?

Yes. Filter by tool name in listScopedTools to expose only what you want. Scalekit also enforces scope checks before every API call.

What happens when a user revokes Quo access?

The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.

Can the agent send texts from Quo?

Yes. quomcp_send_message sends one SMS from a workspace inbox, quomcp_send_group_message sends to 2 to 10 recipients in one shared thread, and quomcp_send_bulk_messages sends separate texts to up to 40 recipients. Leave these tools out of listScopedTools when the agent should only read.

On this page

Tool and actions Framework Compatibility Starter Prompt Auth Lifecycle Try Other Agents Why Scalekit