DevRev MCP connector for AI agents

Tools your support and engineering agent reaches for on DevRev, scoped per user.

CALL ANY TOOL

13 tools for issue tracking in DevRev: search the knowledge graph, list and fetch objects, read sprints and boards, and create, update, link, and comment on issues and tickets.

devrevmcp_add_comment

Add comment

Add a comment to any DevRev object, with support for markdown formatting and user mentions.

Parameters

Name

Type

Required

Description

object

string

Required

DON ID of the DevRev object to comment on.

body

string

Optional

The markdown-formatted body of the comment.

snap_kit_body

string

Optional

Optional snap-kit UI component to render with the comment. Accepts a static snap-kit component as a valid JSON object.

visibility

string

Optional

Visibility of the comment: external (default), internal (dev org only), or private (specified users only). One of: `external`, `internal`, `private`.

devrevmcp_create_object

Create object

devrevmcp_discover_schema

Discover schema

devrevmcp_fetch_object_context

Fetch object context

devrevmcp_get_self

Get self

devrevmcp_get_sprint

Get sprint

devrevmcp_get_sprint_board

Get sprint board

devrevmcp_get_tool_metadata

Get tool metadata

devrevmcp_get_valid_stage_transitions

Get valid stage transitions

devrevmcp_hybrid_search

Search hybrid

devrevmcp_link_objects

Link objects

devrevmcp_list_objects

List objects

devrevmcp_update_object

Update object

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);

// DevRev MCP tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["devrevmcp"], toolNames: [
    "devrevmcp_hybrid_search",
    "devrevmcp_fetch_object_context",
    "devrevmcp_link_objects",
    "devrevmcp_add_comment"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Find open tickets that mention login timeouts" }] });

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: ["devrevmcp"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Find open tickets that mention login timeouts" }],
  tools,
});

// Execute the tool call with the user's vaulted DevRev access 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: ["devrevmcp"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Find open tickets that mention login timeouts" }],
  tools,
});

// Tool call runs with the user's vaulted DevRev access 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: ["devrevmcp"] }, pageSize: 100,
});

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

await agent.run("Find open tickets that mention login timeouts");

Try these prompts

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

Search and triage

Copy the prompt

Copied

Find open tickets that mention login timeouts.

Copy the prompt

Copied

List the issues assigned to me that are still open.

Copy the prompt

Copied

Fetch the full context for TKT-311.

Sprints and stages

Copy the prompt

Copied

Get this sprint board and summarize the work on it.

Copy the prompt

Copied

Which stages can this ticket move to from its current stage?

Copy the prompt

Copied

Show my DevRev profile details.

Updates and comments

Copy the prompt

Copied

Create an issue for the login timeout bug.

Copy the prompt

Copied

Link TKT-311 to ISS-123 as a duplicate.

Copy the prompt

Copied

Add an internal comment on ISS-123 saying the fix is on staging.

SEE HOW AUTH WORKS

Each user connects their own DevRev access token once; Scalekit sends it with every call. Tokens stay vaulted, every call is scope checked, and every action is logged.

Authorize

Your user connects

DevRev 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

DevRev 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

DevRev 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

DevRev 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 issue tracking and developer connectors.

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.

Support and Ops Teams

Support ticket automation agent

Fetches new Zendesk tickets, drafts a reply from Notion knowledge base articles, digests what it cannot answer to Slack, and archives the rest, acting as the support agent rather than a shared API key.

Engineering Teams

Engineering standup agent

Pulls commits from GitHub and GitLab, tracks issue movement in Jira, and posts a per-engineer standup brief to Slack. Each engineer's activity is read on their own delegated OAuth.

Engineering Teams

DevOps assistant agent

Polls GitHub for failing checks and stale PRs, opens Linear issues for the ones that need work, and posts a daily digest to Slack. It acts as the engineer, not a shared service account.

Why Scalekit

Secure your agent's access. Connectors ship in minutes

01.

Shared tokens break per-user analytics

A shared DevRev access token looks fine in a demo. In production every ticket update 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.

DevRev 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 DevRev as the user or through a shared account?

As the user. Each user connects their own DevRev access token once, and Scalekit sends it with every call. Audit logs attribute every ticket update and comment to that user, not a shared service account.

Where is the DevRev access token stored?

In Scalekit's managed AES-256 token vault, namespaced per tenant. To rotate it, the user reconnects with a new access token. Revocation is a single dashboard action. Credentials never appear in prompts, logs, or LLM context.

Can I limit what the agent does in DevRev?

Yes. Filter by tool name in listScopedTools, for example only the search, list, and fetch tools for a read-only triage agent. Scalekit also enforces scope checks before every API call.

What happens when a user revokes DevRev 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.

Which DevRev objects can the agent work with?

Issues, tickets, incidents, conversations, opportunities, accounts, articles, and other objects in DevRev's knowledge graph. The agent finds them with devrevmcp_hybrid_search or devrevmcp_list_objects, reads field schemas with devrevmcp_discover_schema, then creates, updates, links, or comments on them.