MCP: The backbone of joinly

Now you decided to try out joinly for your meetings. But I know there are some crazy people who are eager to deeply understand the main mechanism of the application beyond just using it. Yes, the "MCP (Model Context Protocol)" is a key component of joinly. MCP is everywhere as a new trend in the AI field. But do you really know what MCP is? This article gives an overview for those who want to understand what MCP is and what joinly has to do with it.

Why do we need this new AI trend?

We are living in an era where LLMs can do many magics for us. But often, we get our results from prompts and then still need to copy and paste them manually into other services. Have you ever thought:

"Can’t it be done automatically, connecting directly without our actions?"

Sure, we can connect with an API. But APIs are usually built for a specific service—for example, Google Docs API lets you write to documents, Slack API lets you send messages, and so on. If you want to connect multiple tools together, you often end up stitching APIs with custom scripts or the integration.

That’s where MCP (Model Context Protocol) comes in.

So, what the heck is MCP?

According to Anthropic, the Model Context Protocol (MCP) is "an open standard that enables developers to build secure, two-way connections between their data sources and AI-powered tools."

3 main participants of MCP Architecture

1. HOST : The AI application the user interacts with (e.g., Claude desktop, IDE), managing the user experience and multiple clients.

2. CLIENT : A component inside the host that handles connections to MCP servers.

3. SERVER : The actual provider of external functionality (e.g., Google Docs, Slack). 3-1. Tools – executable functions (e.g., create a doc, book a flight).

   3-2. Resources – data the AI can fetch or access (e.g., files, calendar events).

   3-3. Prompts – predefined templates that guide AI interactions (e.g., "Search the flight").

For more details, see the documentation at Official document of MCP and Anthropic’s announcement at Anthropic News

Let's have a look into joinly MCP structure

Here we see the beautiful structure of joinly.ai!

💡

Joinly is organized into two main parts:

1. MCP Server (Joinly MCP server)
2. MCP Client (Joinly client)

You can use these different components to mix and match setups to fit your needs.

Option A — self-hosted (GitHub)

1. Quickstart — MCP Server + built-in Client (Quickstart)

   Run the Docker image with the --client flag to spin up the joinly MCP server and the joinly client package together. This is great for a quick smoke test; however, no external MCP clients can connect in this mode.

   Why use it?

   • Zero config beyond env vars and a meeting link
   • Perfect for trying real-time speech and live transcript quickly and locally

2. Typical setup — Joinly server + external MCP client (External Client)

   Start the joinly MCP server and connect an external MCP client (we recommend our dedicated joinly-client package, but you can use tools like Claude Desktop). This setup lets you also connect other MCP servers (e.g., Tavily, Notion).

   Why use it?

   • Works with real hosts (e.g., Claude Desktop) and client configs
   • Add multiple servers for search, notes, docs, etc.

Option B — joinly cloud (Cloud)

No local setup. Use the hosted experience to try the meeting agent and features right away.

Why use it?

• Zero install & upkeep: skip Docker, keys, and local dependencies
• Fastest path to value: immediately try real-time speaking and transcript access
• Bring your favorites: connect OAuth-enabled MCP servers

---

What does the joinly MCP server actually provide?

Tools :

• join_meeting - Join meeting with URL, participant name, and optional passcode
• leave_meeting - Leave the current meeting
• speak_text - Speak text using TTS (requires text parameter)
• send_chat_message - Send chat message (requires message parameter)
• mute_yourself - Mute microphone
• unmute_yourself - Unmute microphone
• get_chat_history - Get current meeting chat history in JSON format
• get_participants - Get current meeting participants in JSON format
• get_transcript - Get current meeting transcript in JSON format, optionally filtered by minutes

Resources :

• transcript://live - Live meeting transcript in JSON format, including timestamps and speaker information. Subscribable for real-time updates when new utterances are added.

How can we use the external MCP client?

The coolest part about using an external client is that you can connect to as many MCP servers as you like (e.g., Notion, Tavily, etc.) to your client. So that you can use tools of MCP servers in the meeting!

Let's do it now!

🤖 Assemble your joinly like LEGO with MCP servers

STEP1 : Shop your MCP servers that you want to use. For example, you can check out lists of MCP servers here → MCP servers

e.g. Notion - This project implements an MCP server for the Notion API Tavily - Search engine for AI agents (search + extract) powered by AlphaAI Technologies Inc

X (Twitter) (by vidhupv) - Create, manage and publish X/Twitter posts directly through Claude chat ...

STEP 2: Take the JSON configuration from the MCP server and add it to the joinly client. Check our documentation for more detail : Add MCP servers to the client. For example, here we want to connect the Notion MCP!

{
    "mcpServers": {
        "notion": {
            "command": "npx",
            "args": ["-y", "@notionhq/notion-mcp-server"],
            "env": {
                "OPENAPI_MCP_HEADERS": "{\"Authorization\": \"Bearer ntn_****\", \"Notion-Version\": \"2022-06-28\"}"
            }
        }
    }
}

STEP3 : Enjoy the richful meeting with your own joinly!