Make your meetings accessible to AI Agents 🤖

joinly.ai is a connector middleware designed to enable AI agents to join and actively participate in video calls. Through its MCP server, joinly.ai provides essential meeting tools and resources that can equip any AI agent with the skills to perform tasks and interact with you in real time during your meetings.

Want to dive right in? Jump to the Quickstart! Want to know more? Visit our website!

[!IMPORTANT]
Don't want the hustle of setting everything up? Try our cloud first! ☁️🚀

:sparkles: Features

• Live Interaction: Lets your agents execute tasks and respond in real-time by voice or chat within your meetings
• Conversational flow: Built-in logic that ensures natural conversations by handling interruptions and multi-speaker interactions
• Cross-platform: Join Google Meet, Zoom, and Microsoft Teams (or any available over the browser)
• Bring-your-own-LLM: Works with all LLM providers (also locally with Ollama)
• Choose-your-preferred-TTS/STT: Modular design supports multiple services - Whisper/Deepgram for STT and Kokoro/ElevenLabs/Deepgram for TTS (and more to come...)
• 100% open-source, self-hosted and privacy-first :rocket:

:video_camera: Demos

GitHub

In this demo video, joinly answers the question 'What is Joinly?' by accessing the latest news from the web. It then creates an issue in a GitHub demo repository.

Notion

In this demo video, we connect joinly to our notion via MCP and let it edit the content of a page content live in the meeting.

Any ideas what we should build next? Write us! :rocket:

:zap: Quickstart

Run joinly via Docker with a basic conversational agent client.

[!IMPORTANT] Prerequisites: Docker installation

Create a new folder joinly or clone this repository (not mandatory for the following steps). In this directory, create a new .env file with a valid API key for the LLM provider you want to use, e.g. OpenAI:

[!TIP] You can find the OpenAI API key here

# .env
# for OpenAI LLM
# change key and model to your desired one
JOINLY_LLM_MODEL=gpt-4o
JOINLY_LLM_PROVIDER=openai
OPENAI_API_KEY=your-openai-api-key

[!NOTE] See .env.example for complete configuration options including Anthropic (Claude) and Ollama setups. Replace the placeholder values with your actual API keys and adjust the model name as needed. Delete the placeholder values of the providers you don't use.

Pull the Docker image (~2.3GB since it packages browser and models):

docker pull ghcr.io/joinly-ai/joinly:latest

Launch your meeting in Zoom, Google Meet or Teams and let joinly join the meeting using the meeting link as <MeetingURL>. Then, run the following command from the folder where you created the .env file:

docker run --env-file .env ghcr.io/joinly-ai/joinly:latest --client <MeetingURL>

:red_circle: Having trouble getting started? Let's figure it out together on our discord!

:technologist: Run a custom client

In Quickstart, we ran the Docker Container directly as a client using --client. But we can also run it as a server and connect to it from outside the container, which allows us to connect other MCP servers. Here, we run a custom client using the joinly-client package and connect it to the joinly MCP server.

[!IMPORTANT] Prerequisites: do the Quickstart (except the last command), install uv, and open two terminals

Start the joinly server in the first terminal (note, we are not using --client here and publish port 8000 on localhost only):

docker run -p 127.0.0.1:8000:8000 ghcr.io/joinly-ai/joinly:latest

[!WARNING] The joinly MCP server has no authentication and accepts client-supplied configuration, so it is meant to run locally with a single trusted client. Bind it to localhost (as above) and do not expose the port to a network.

While the server is running, start the example client implementation in the second terminal window to connect to it and join a meeting:

uvx joinly-client --env-file .env <MeetingUrl>

Add MCP servers to the client

Add the tools of any MCP server to the agent by providing a JSON configuration. The configuration file can contain multiple entries under "mcpServers" which will all be available as tools in the meeting (see fastmcp client docs for config syntax):

{
    "mcpServers": {
        "localServer": {
            "command": "npx",
            "args": ["-y", "package@0.1.0"]
        },
        "remoteServer": {
            "url": "http://mcp.example.com",
            "auth": "oauth"
        }
    }
}

Add for example a Tavily config for web searching, then run the client using the config file, here named config.json:

uvx joinly-client --env-file .env --mcp-config config.json <MeetingUrl>

:wrench: Configurations

Configurations can be given via env variables and/or command line args. Here is a list of common configuration options, which can be used when starting the docker container:

docker run --env-file .env -p 127.0.0.1:8000:8000 ghcr.io/joinly-ai/joinly:latest <MyOptionArgs>

Alternatively, you can pass --name, --lang, and provider settings as command line arguments using joinly-client, which will override settings of the server:

uvx joinly-client <MyOptionArgs> <MeetingUrl>

Basic Settings

In general, the docker image provides an MCP server which is started by default. But to quickly get started, we also include a client implementation that can be used via --client. Note, in this case no server is started and no other client can connect to it.

# Start directly as client; default is as server, to which a custom client can connect
--client <MeetingUrl>

# Change participant name (default: joinly)
--name "AI Assistant"

# Change language of TTS/STT (default: en)
# Note, availability depends on the TTS/STT provider
--lang de

# Change host & port of the joinly MCP server
--host 0.0.0.0 --port 8000

Providers

Text-to-Speech

# Kokoro (local) TTS (default)
--tts kokoro
--tts-arg voice=<VoiceName>  # optionally, set different voice

# ElevenLabs TTS, include ELEVENLABS_API_KEY in .env
--tts elevenlabs
--tts-arg voice_id=<VoiceID>  # optionally, set different voice

# Deepgram TTS, include DEEPGRAM_API_KEY in .env
--tts deepgram
--tts-arg model_name=<ModelName>  # optionally, set different model (voice)

Transcription

# Whisper (local) STT (default)
--stt whisper
--stt-arg model_name=<ModelName>  # optionally, set different model (default: base), for GPU support see below

# Deepgram STT, include DEEPGRAM_API_KEY in .env
--stt deepgram
--stt-arg model_name=<ModelName>  # optionally, set different model

Debugging

# Start browser with a VNC server for debugging;
# forward the port and connect to it using a VNC client
--vnc-server --vnc-server-port 5900

# Logging
-v  # or -vv, -vvv

# Help
--help

GPU Support

We provide a Docker image with CUDA GPU support for running the transcription and TTS models on a GPU. To use it, you need to have the NVIDIA Container Toolkit installed and CUDA >= 12.6. Then pull the CUDA-enabled image:

docker pull ghcr.io/joinly-ai/joinly:latest-cuda