How do I connect my AI agent to multiple MCP servers (Discord, Calendly, Figma)?

Connecting to multiple MCP servers like Discord, Calendly, Figma allows your AI agent to leverage capabilities from each service simultaneously. You can configure each server connection independently in your MCP client, and your AI agent will be able to use tools from all connected servers in a single conversation. Klavis AI simplifies this process with centralized connection management.

What are the benefits of using Discord and Calendly and Figma together?

Using Discord and Calendly and Figma together creates powerful synergies for your AI workflows. Each service brings unique capabilities that complement each other, enabling more comprehensive automation and data processing across multiple platforms.

Do I need authentication to use these MCP servers?

Authentication requirements depend on the specific MCP server and the operations you want to perform. Some of these servers require OAuth or API key authentication for full functionality. Klavis AI handles the authentication flow automatically once you provide the necessary credentials, making the setup process seamless.

What is the Model Context Protocol (MCP)?

The Model Context Protocol (MCP) is an open standard that enables AI assistants to securely connect to external tools and data sources. It provides a consistent way for AI agents to interact with various services, databases, and APIs while maintaining security and reliability.

Is it safe to connect my AI agent to these services?

Yes, MCP connections are designed with security in mind. All communications are secured, and you maintain control over what data and operations your AI agent can access. Klavis AI implements additional security measures and follows best practices for data protection, ensuring your connections are safe and reliable.

Can I use these MCP servers with any AI model?

MCP servers are designed to work with various AI models and clients that support the Model Context Protocol. Popular AI assistants like Claude, ChatGPT, and others can connect to MCP servers when properly configured.

How does Klavis AI make MCP server connections easier?

Klavis AI provides a comprehensive platform for managing MCP server connections with features like automated setup, centralized connection management, detailed configuration guides, and secure credential storage. Our platform simplifies the entire process from discovery to deployment, making it easy for both beginners and experts to leverage the power of MCP servers.

Connectto Discord, Calendly, Figma MCP Servers

Create powerful AI workflows by connecting multiple MCP servers including Discord, Calendly, Figma for enhanced automation capabilities in Klavis AI.

Get Started Free View All MCP Servers

Discord

featured

Discord is a VoIP and instant messaging social platform

Available Tools:

discord_get_server_info
discord_list_members
discord_create_text_channel
+6 more tools

Calendly

coming soon

Manage scheduling and appointments with your agents.

Figma

featured

Figma is a collaborative interface design tool for web and mobile applications.

Quick Setup Guide

Follow these steps to connect your AI agents to these MCP servers

Create Your Account

Configure Connections

Add your desired MCP servers to your AI client and configure authentication settings.

Test & Deploy

Verify your connections work correctly and start using your enhanced AI capabilities.

Integrate in minutes, Scale to millions

View Documentation

from klavis import Klavis

klavis_client = Klavis(api_key="KLAVIS_API_KEY")

servers = ["Discord", "Calendly", "Figma"]
responses = []

for server in servers:
    mcp_server = klavis_client.mcp_server.create_server_instance(
        server_name=server,
        user_id="<USER_ID>"
    )
    responses.append(mcp_server)

Code Examples for claude

import os
import json
from anthropic import Anthropic
from klavis import Klavis
from klavis.types import McpServerName, ConnectionType, ToolFormat

# Initialize clients
anthropic_client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))

# Constants
CLAUDE_MODEL = "claude-3-5-sonnet-20241022"
user_message = "Your message here"

discord_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.DISCORD,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

calendly_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.CALENDLY,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

figma_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.FIGMA,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

# Get tools from all MCP servers
discord_tools = klavis_client.mcp_server.list_tools(
    server_url=discord_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.ANTHROPIC,
)
calendly_tools = klavis_client.mcp_server.list_tools(
    server_url=calendly_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.ANTHROPIC,
)
figma_tools = klavis_client.mcp_server.list_tools(
    server_url=figma_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.ANTHROPIC,
)

# Combine all tools
all_tools = []
all_tools.extend(discord_tools.tools)
all_tools.extend(calendly_tools.tools)
all_tools.extend(figma_tools.tools)

messages = [
    {"role": "user", "content": user_message}
]
        
response = anthropic_client.messages.create(
    model=CLAUDE_MODEL,
    max_tokens=4000,
    messages=messages,
    tools=all_tools
)

import Anthropic from '@anthropic-ai/sdk';
import { KlavisClient, Klavis } from 'klavis';

// Initialize clients
const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });

const CLAUDE_MODEL = "claude-3-5-sonnet-20241022";
const userMessage = "Your message here";

const discordMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Discord,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const calendlyMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Calendly,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const figmaMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Figma,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

// Get tools from all MCP servers
const discordTools = await klavisClient.mcpServer.listTools({
    serverUrl: discordMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Anthropic,
});
const calendlyTools = await klavisClient.mcpServer.listTools({
    serverUrl: calendlyMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Anthropic,
});
const figmaTools = await klavisClient.mcpServer.listTools({
    serverUrl: figmaMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Anthropic,
});

// Combine all tools
const allTools = [
    ...discordTools.tools,
    ...calendlyTools.tools,
    ...figmaTools.tools
];

const response = await anthropic.messages.create({
    model: CLAUDE_MODEL,
    max_tokens: 4000,
    messages: [{ role: 'user', content: userMessage }],
    tools: allTools,
});

Code Examples for openai

import json
import os
from openai import OpenAI
from klavis import Klavis
from klavis.types import McpServerName, ConnectionType, ToolFormat

# Initialize clients
openai_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))

# Constants
OPENAI_MODEL = "gpt-4o-mini"

discord_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.DISCORD,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

calendly_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.CALENDLY,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

figma_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.FIGMA,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

# Get tools from all MCP servers
discord_tools = klavis_client.mcp_server.list_tools(
    server_url=discord_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
calendly_tools = klavis_client.mcp_server.list_tools(
    server_url=calendly_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
figma_tools = klavis_client.mcp_server.list_tools(
    server_url=figma_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)

# Combine all tools
all_tools = []
all_tools.extend(discord_tools)
all_tools.extend(calendly_tools)
all_tools.extend(figma_tools)

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": user_message}
]
        
response = openai_client.chat.completions.create(
    model=OPENAI_MODEL,
    messages=messages,
    tools=all_tools if all_tools else None
)

import OpenAI from 'openai';
import { KlavisClient, Klavis } from 'klavis';

// Initialize clients
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });

const OPENAI_MODEL = "gpt-4o-mini";
const userMessage = "Your query here";

const discordMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Discord,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const calendlyMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Calendly,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const figmaMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Figma,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

// Get tools from all MCP servers
const discordTools = await klavisClient.mcpServer.listTools({
    serverUrl: discordMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});
const calendlyTools = await klavisClient.mcpServer.listTools({
    serverUrl: calendlyMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});
const figmaTools = await klavisClient.mcpServer.listTools({
    serverUrl: figmaMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});

// Combine all tools
const allTools = [
    ...discordTools,
    ...calendlyTools,
    ...figmaTools
];

const response = await openai.chat.completions.create({
    model: OPENAI_MODEL,
    messages: [
        { role: 'system', content: 'You are a helpful assistant.' },
        { role: 'user', content: userMessage }
    ],
    tools: allTools,
});

Code Examples for gemini

import os
from google import genai
from klavis import Klavis
from klavis.types import McpServerName, ConnectionType, ToolFormat

# Initialize clients
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
client = genai.Client(api_key=os.getenv("GOOGLE_API_KEY"))

user_message = "Your query here"

discord_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.DISCORD,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

calendly_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.CALENDLY,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

figma_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.FIGMA,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

# Get tools from all MCP servers
discord_tools = klavis_client.mcp_server.list_tools(
    server_url=discord_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.GEMINI,
)
calendly_tools = klavis_client.mcp_server.list_tools(
    server_url=calendly_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.GEMINI,
)
figma_tools = klavis_client.mcp_server.list_tools(
    server_url=figma_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.GEMINI,
)

# Combine all tools
all_tools = []
all_tools.extend(discord_tools.tools)
all_tools.extend(calendly_tools.tools)
all_tools.extend(figma_tools.tools)

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=user_message,
    config=genai.types.GenerateContentConfig(
        tools=all_tools,
    ),
)

import { GoogleGenAI } from '@google/genai';
import { KlavisClient, Klavis } from 'klavis';

// Initialize clients
const ai = new GoogleGenAI({ apiKey: process.env.GOOGLE_API_KEY });
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });

const userMessage = "Your query here";

const discordMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Discord,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const calendlyMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Calendly,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const figmaMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Figma,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

// Get tools from all MCP servers
const discordTools = await klavisClient.mcpServer.listTools({
    serverUrl: discordMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Gemini,
});
const calendlyTools = await klavisClient.mcpServer.listTools({
    serverUrl: calendlyMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Gemini,
});
const figmaTools = await klavisClient.mcpServer.listTools({
    serverUrl: figmaMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Gemini,
});

// Combine all tools
const allTools = [
    ...discordTools.tools,
    ...calendlyTools.tools,
    ...figmaTools.tools
];

const response = await ai.models.generateContent({
    model: "gemini-2.5-flash",
    contents: userMessage,
    tools: allTools,
});

Code Examples for langchain

import os
import asyncio
from klavis import Klavis
from klavis.types import McpServerName, ConnectionType
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

# Initialize clients
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
llm = ChatOpenAI(model="gpt-4o-mini", api_key=os.getenv("OPENAI_API_KEY"))

discord_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.DISCORD,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

calendly_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.CALENDLY,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

figma_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.FIGMA,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

mcp_client = MultiServerMCPClient({
    "discord": {
        "transport": "streamable_http",
        "url": discord_mcp_instance.server_url
    },
    "calendly": {
        "transport": "streamable_http",
        "url": calendly_mcp_instance.server_url
    },
    "figma": {
        "transport": "streamable_http",
        "url": figma_mcp_instance.server_url
    }
})

tools = asyncio.run(mcp_client.get_tools())

agent = create_react_agent(
    model=llm,
    tools=tools,
)

response = asyncio.run(agent.ainvoke({
    "messages": [{"role": "user", "content": "Your query here"}]
}))

import { KlavisClient, Klavis } from 'klavis';
import { MultiServerMCPClient } from "@langchain/mcp-adapters";
import { ChatOpenAI } from "@langchain/openai";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

// Initialize clients
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });
const llm = new ChatOpenAI({ model: "gpt-4o-mini", apiKey: process.env.OPENAI_API_KEY });

const discordMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Discord,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const calendlyMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Calendly,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const figmaMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Figma,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const mcpClient = new MultiServerMCPClient({
    "discord": {
        transport: "streamable_http",
        url: discordMcpInstance.serverUrl
    },
    "calendly": {
        transport: "streamable_http",
        url: calendlyMcpInstance.serverUrl
    },
    "figma": {
        transport: "streamable_http",
        url: figmaMcpInstance.serverUrl
    }
});

const tools = await mcpClient.getTools();

const agent = createReactAgent({
    llm: llm,
    tools: tools,
});

const response = await agent.invoke({
    messages: [{ role: "user", content: "Your query here" }]
});

Code Examples for llamaindex

import os
from klavis import Klavis
from klavis.types import McpServerName, ConnectionType
from llama_index.tools.mcp import (
    BasicMCPClient,
    get_tools_from_mcp_url,
    aget_tools_from_mcp_url,
)
from llama_index.core.agent.workflow import FunctionAgent, AgentWorkflow

# Initialize clients
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))

discord_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.DISCORD,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

calendly_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.CALENDLY,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

figma_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.FIGMA,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)
discord_tools = await aget_tools_from_mcp_url(
    discord_mcp_instance.server_url, 
    client=BasicMCPClient(discord_mcp_instance.server_url)
)
calendly_tools = await aget_tools_from_mcp_url(
    calendly_mcp_instance.server_url, 
    client=BasicMCPClient(calendly_mcp_instance.server_url)
)
figma_tools = await aget_tools_from_mcp_url(
    figma_mcp_instance.server_url, 
    client=BasicMCPClient(figma_mcp_instance.server_url)
)

discord_agent = FunctionAgent(
    name="discord_agent",
    tools=discord_tools,
    llm=llm,
)

calendly_agent = FunctionAgent(
    name="calendly_agent",
    tools=calendly_tools,
    llm=llm,
)

figma_agent = FunctionAgent(
    name="figma_agent",
    tools=figma_tools,
    llm=llm,
)
workflow = AgentWorkflow(
    agents=[discord_agent, calendly_agent, figma_agent],
    root_agent="discord_agent",
)

import { KlavisClient, Klavis } from 'klavis';
import { mcp } from "@llamaindex/tools";
import { agent, multiAgent } from "@llamaindex/workflow";
import { openai } from "@llamaindex/llm";

// Initialize clients
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });

const discordMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Discord,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const calendlyMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Calendly,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const figmaMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Figma,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

// Create MCP server connections
const discordServer = mcp({
    url: discordMcpInstance.serverUrl,
    verbose: true,
});
const calendlyServer = mcp({
    url: calendlyMcpInstance.serverUrl,
    verbose: true,
});
const figmaServer = mcp({
    url: figmaMcpInstance.serverUrl,
    verbose: true,
});

// Get tools from MCP servers
const discordTools = await discordServer.tools();
const calendlyTools = await calendlyServer.tools();
const figmaTools = await figmaServer.tools();

// Create specialized agents
const discordAgent = agent({
    name: "discord_agent",
    llm: openai({ model: "gpt-4o" }),
    tools: discordTools,
});

const calendlyAgent = agent({
    name: "calendly_agent",
    llm: openai({ model: "gpt-4o" }),
    tools: calendlyTools,
});

const figmaAgent = agent({
    name: "figma_agent",
    llm: openai({ model: "gpt-4o" }),
    tools: figmaTools,
});

// Create multi-agent workflow
const agents = multiAgent({
    agents: [discordAgent, calendlyAgent, figmaAgent],
    rootAgent: discordAgent,
});

Code Examples for crewai

import os
from crewai import Agent, Task, Crew, Process
from crewai_tools import MCPServerAdapter
from klavis import Klavis
from klavis.types import McpServerName, ConnectionType

# Initialize clients
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))

discord_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.DISCORD,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

calendly_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.CALENDLY,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

figma_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.FIGMA,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

# Initialize MCP tools for each server
discord_tools = MCPServerAdapter(discord_mcp_instance.server_params)
calendly_tools = MCPServerAdapter(calendly_mcp_instance.server_params)
figma_tools = MCPServerAdapter(figma_mcp_instance.server_params)

# Create specialized agents for each service
discord_agent = Agent(
    role="Discord Specialist",
    goal="Handle all Discord related tasks and data processing",
    backstory="You are an expert in Discord operations and data analysis",
    tools=discord_tools,
    reasoning=True,
    verbose=False
)

calendly_agent = Agent(
    role="Calendly Specialist",
    goal="Handle all Calendly related tasks and data processing",
    backstory="You are an expert in Calendly operations and data analysis",
    tools=calendly_tools,
    reasoning=True,
    verbose=False
)

figma_agent = Agent(
    role="Figma Specialist",
    goal="Handle all Figma related tasks and data processing",
    backstory="You are an expert in Figma operations and data analysis",
    tools=figma_tools,
    reasoning=True,
    verbose=False
)

# Define collaborative tasks
research_task = Task(
    description="Gather comprehensive data from all available sources",
    expected_output="Raw data and initial findings from all services",
    agent=discord_agent,
    markdown=True
)

# Create multi-agent crew
crew = Crew(
    agents=[discord_agent, calendly_agent, figma_agent],
    tasks=[research_task],
    verbose=False,
    process=Process.sequential
)

result = crew.kickoff()

// CrewAI currently only supports Python. Please use the Python example.

Code Examples for fireworks-ai

import os
import json
from fireworks.client import Fireworks
from klavis import Klavis
from klavis.types import McpServerName, ConnectionType, ToolFormat

# Initialize clients
fireworks_client = Fireworks(api_key=os.getenv("FIREWORKS_API_KEY"))
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))

discord_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.DISCORD,
    user_id="1234",
    platform_name="Klavis",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

calendly_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.CALENDLY,
    user_id="1234",
    platform_name="Klavis",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

figma_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.FIGMA,
    user_id="1234",
    platform_name="Klavis",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

# Get all MCP tools
discord_tools = klavis_client.mcp_server.list_tools(
    server_url=discord_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
calendly_tools = klavis_client.mcp_server.list_tools(
    server_url=calendly_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
figma_tools = klavis_client.mcp_server.list_tools(
    server_url=figma_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)

# Combine all tools
all_tools = []
all_tools.extend(discord_tools.tools)
all_tools.extend(calendly_tools.tools)
all_tools.extend(figma_tools.tools)

messages = [
    {"role": "system", "content": "You are a helpful assistant with access to multiple data sources."},
    {"role": "user", "content": user_message}
]

response = fireworks_client.chat.completions.create(
    model="accounts/fireworks/models/llama-v3p1-70b-instruct",
    messages=messages,
    tools=all_tools
)

import Fireworks from 'fireworks-ai';
import { KlavisClient, Klavis } from 'klavis';

// Initialize clients
const fireworks = new Fireworks({ apiKey: process.env.FIREWORKS_API_KEY });
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });

const discordMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Discord,
    userId: "1234",
    platformName: "Klavis",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const calendlyMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Calendly,
    userId: "1234",
    platformName: "Klavis",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const figmaMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Figma,
    userId: "1234",
    platformName: "Klavis",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

// Get all MCP tools
const discordTools = await klavisClient.mcpServer.listTools({
    serverUrl: discordMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});
const calendlyTools = await klavisClient.mcpServer.listTools({
    serverUrl: calendlyMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});
const figmaTools = await klavisClient.mcpServer.listTools({
    serverUrl: figmaMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});

// Combine all tools
const allTools = [
    ...discordTools.tools,
    ...calendlyTools.tools,
    ...figmaTools.tools
];

const response = await fireworks.chat.completions.create({
    model: "accounts/fireworks/models/llama-v3p1-70b-instruct",
    messages: [
        { role: "system", content: "You are a helpful assistant with access to multiple data sources." },
        { role: "user", content: userMessage }
    ],
    tools: allTools,
});

Code Examples for together-ai

import os
import json
from together import Together
from klavis import Klavis
from klavis.types import McpServerName, ConnectionType, ToolFormat

# Initialize clients
together_client = Together(api_key=os.getenv("TOGETHER_API_KEY"))
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))

discord_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.DISCORD,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

calendly_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.CALENDLY,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

figma_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.FIGMA,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)

# Get all MCP tools
discord_tools = klavis_client.mcp_server.list_tools(
    server_url=discord_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
calendly_tools = klavis_client.mcp_server.list_tools(
    server_url=calendly_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
figma_tools = klavis_client.mcp_server.list_tools(
    server_url=figma_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)

# Combine all tools
all_tools = []
all_tools.extend(discord_tools.tools)
all_tools.extend(calendly_tools.tools)
all_tools.extend(figma_tools.tools)

messages = [
    {"role": "system", "content": "You are a helpful AI assistant with access to multiple data sources."},
    {"role": "user", "content": user_message}
]

response = together_client.chat.completions.create(
    model="meta-llama/Llama-2-70b-chat-hf",
    messages=messages,
    tools=all_tools
)

import Together from 'together-ai';
import { KlavisClient, Klavis } from 'klavis';

// Initialize clients
const togetherClient = new Together({ apiKey: process.env.TOGETHER_API_KEY });
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });

const discordMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Discord,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const calendlyMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Calendly,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const figmaMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Figma,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

// Get all MCP tools
const discordTools = await klavisClient.mcpServer.listTools({
    serverUrl: discordMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});
const calendlyTools = await klavisClient.mcpServer.listTools({
    serverUrl: calendlyMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});
const figmaTools = await klavisClient.mcpServer.listTools({
    serverUrl: figmaMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});

// Combine all tools
const allTools = [
    ...discordTools.tools,
    ...calendlyTools.tools,
    ...figmaTools.tools
];

const response = await togetherClient.chat.completions.create({
    model: "meta-llama/Llama-2-70b-chat-hf",
    messages: [
        { role: "system", content: "You are a helpful AI assistant with access to multiple data sources." },
        { role: "user", content: userMessage }
    ],
    tools: allTools,
});

Frequently Asked Questions

Everything you need to know about connecting to these MCP servers

Ready to Get Started?

Join developers who are already using KlavisAI to power their AI agents and AI applications with these MCP servers.

Start For Free

ConnectAI Agentsto Discord, Calendly, Figma MCP Servers