# Getting started - MCP at Zoom

<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->

Zoom's MCP servers follow the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction/), which is an open standard that allows applications to share API context with large language models (LLMs), enabling the development of smart agents and automated workflows.

MCP provides a consistent way for AI agents to **discover, authenticate, and use tools dynamically** without requiring custom integrations for each system.
Connecting an MCP server to your Zoom AI app lets your app interact with external data systems.

## Benefits

Cross-platform AI workflows enable you to:

-   **Enhance Zoom AI Companion and custom agents with context-awareness** by connecting external MCP servers to Zoom AI Studio, making institutional knowledge and internal tools available across the Zoom platform.
-   **Access Zoom data from external AI platforms using MCP**, allowing other MCP-compatible systems to work with Zoom content in a consistent, standardized way
-   **Reduce integration and maintenance overhead** by using standardized AI tool access instead of building and supporting custom connectors for each system
-   **Scale AI adoption with built-in governance** by relying on OAuth, scoped permissions, and admin controls to manage access safely across the organization

---

## Ecosystem and components

The Model Context Protocol (MCP) ecosystem comprises several components that work together to connect AI systems with external tools and services.

The most common concepts and components are:

-   **MCP Clients** - Consume MCP services and interact with AI systems.

-   **MCP Plugins** - Provide commands, workflows, and user-facing functionality.

-   **MCP Connectors** - Handle secure communication and authentication.

-   **MCP Servers** - Expose tools and resources through the MCP protocol.

Although they are related, each serves a different role, and together, these components allow AI systems to securely interact with external platforms such as Zoom, GitHub, Slack, and many others.

> **Component names are not consistent across the industry**
>
> As you become more familiar with MCP offerings by different services, you will notice that the terminology for components is not used consistently across the industry. For example, companies may refer to their plugins as connectors and vice-versa.

---

## High-Level Architecture

```plaintext
User
  ↓
AI Application / Agent
  ↓
MCP Client
  ↓
MCP Plugin
  ↓
MCP Connector
  ↓
MCP Server
  ↓
External Service
```

Example external services:

-   Zoom
-   GitHub
-   Slack
-   Jira
-   Google Drive

You can think of the architecture like this:

| Component     | Analogy            |
| ------------- | ------------------ |
| MCP Client    | Web browser        |
| MCP Plugin    | Browser extension  |
| MCP Connector | Network connection |
| MCP Server    | Web service/API    |

---

## MCP Clients

An **MCP client** is an application or AI system that communicates with MCP servers.

It is the component that consumes MCP tools, data, and capabilities.

MCP clients typically:

-   Connect to MCP servers
-   Send MCP requests
-   Receive responses
-   Discover tools and capabilities
-   Provide context to AI models
-   Execute tool calls

### Examples

-   AI assistants
-   IDE integrations
-   AI coding agents
-   Chat interfaces
-   Desktop AI applications

### Example Workflow

An MCP client might:

-   Connect to a Zoom MCP server
-   Discover available tools
-   Ask the server to create a meeting
-   Return the result to the AI model

---

## MCP Plugins

Plugins define what users can do. An **MCP plugin** adds functionality or workflows to an MCP client.

Plugins are usually user-facing and provide commands, automations, or integrations built on top of MCP services.

Plugins typically:

-   Define commands
-   Coordinate workflows
-   Call MCP tools
-   Format responses
-   Add automation logic
-   Extend AI behavior

### Examples

A Zoom MCP plugin might provide commands such as:

```bash
/zoom:meetings:create
/zoom:chat:send
/zoom:summary
```

A GitHub MCP plugin might provide:

```bash
/github:pr:review
/github:issues:list
```

---

## MCP Connectors

Connectors define how systems communicate. An **MCP connector** handles communication between MCP clients/plugins and MCP servers.

Connectors focus on transport, authentication, and connectivity.

Connectors typically handle:

-   OAuth authentication
-   API keys
-   HTTP/WebSocket transport
-   Token refresh
-   Session management
-   Endpoint configuration

### Example

A Zoom MCP connector may:

-   Authenticate with Zoom
-   Connect to Zoom MCP endpoints
-   Maintain active sessions
-   Refresh expired tokens

---

## Comparison Table

| Component     | Primary Purpose                   | User Facing | Handles Auth | Executes Workflows |
| ------------- | --------------------------------- | ----------- | ------------ | ------------------ |
| MCP Client    | Consume MCP capabilities          | Yes         | Sometimes    | Sometimes          |
| MCP Plugin    | Add functionality and workflows   | Yes         | Usually no   | Yes                |
| MCP Connector | Handle connectivity and transport | No          | Yes          | No                 |
| MCP Server    | Expose tools and resources        | No          | Sometimes    | Yes                |

---