How do I use multiple MCP servers (Google Drive, Discord, Google Docs) with OpenAI?

OpenAI supports using multiple MCP servers simultaneously through function calling. You can configure each Google Drive, Discord, Google Docs server independently and combine their tools in a single OpenAI chat completion request. This enables powerful multi-service AI applications where your OpenAI models can access data and perform actions across Google Drive, Discord, Google Docs within a single conversation. Klavis AI simplifies multi-server management with centralized configuration and unified tool formatting for OpenAI function calling.

What are the benefits of using Google Drive and Discord and Google Docs together with OpenAI?

Combining Google Drive and Discord and Google Docs with OpenAI creates powerful synergies for advanced AI applications. Each service brings unique capabilities that complement each other, enabling comprehensive data access, cross-platform automation, and enhanced AI responses with multi-source information gathering and action execution.

Do I need special packages for OpenAI MCP server integration?

You only need the standard OpenAI Python or TypeScript/JavaScript client library. Klavis AI handles all the MCP server communication and formats the tools specifically for OpenAI's function calling format. Our platform provides detailed setup instructions, code examples for both Python and TypeScript, and troubleshooting guides to ensure smooth integration with your existing OpenAI applications.

How does function calling work with MCP servers in OpenAI?

MCP servers integrate with OpenAI through the function calling feature. Klavis AI automatically formats MCP server tools as OpenAI functions, allowing your models to call them naturally during conversations. When the model needs to use a tool, it generates a function call, which is then executed against the MCP server, and the results are returned to continue the conversation flow.

How do I handle authentication for MCP servers with OpenAI?

Authentication for MCP servers is handled by Klavis AI, separate from your OpenAI API key. Each MCP server may require different authentication methods (API keys, OAuth tokens, etc.). Klavis AI manages the authentication flow automatically once you provide the necessary credentials, ensuring secure access to external services while your OpenAI integration remains simple and clean.

Can I use streaming responses with these MCP servers and OpenAI?

Yes, OpenAI's streaming responses work seamlessly with MCP server integration. When using function calling with streaming, OpenAI will stream the model's reasoning and then execute function calls as needed. These MCP servers support real-time data access, making streaming responses even more dynamic and responsive. Klavis AI optimizes the connection for low-latency streaming scenarios.

What types of OpenAI applications benefit most from MCP server integration?

OpenAI applications that benefit most include: customer service chatbots needing real-time data access, AI assistants that perform actions across multiple platforms, content generation tools requiring up-to-date information, and conversational AI that needs to integrate with business systems. MCP servers extend OpenAI beyond text generation to become powerful action-oriented AI agents.

How does MCP server integration affect OpenAI API costs and performance?

MCP server integration may increase token usage slightly due to function definitions being included in requests, but the cost impact is typically minimal compared to the added functionality. The integration adds minimal latency for tool calls. Best practices include using appropriate timeouts, implementing retry logic, and caching frequently accessed data. Klavis AI provides cost optimization recommendations and performance monitoring to help you manage both OpenAI API costs and MCP server usage efficiently.

Why choose Klavis AI for OpenAI MCP server connections?

Klavis AI provides the most comprehensive platform for OpenAI MCP server integration with features like automatic function calling formatting, one-click server setup, detailed OpenAI-specific documentation and code examples, secure credential management, and performance optimization guides. Our platform is specifically designed to make OpenAI + MCP server integration as seamless as possible for developers building advanced conversational AI and agent applications. With Klavis AI's centralized management dashboard, you can monitor all your MCP server connections, track OpenAI API usage, and troubleshoot issues from a single interface.

Connectto Google Drive, Discord, Google Docs MCP Servers

Create powerful AI workflows by connecting multiple MCP servers including Google Drive, Discord, Google Docs for enhanced automation capabilities in Klavis AI.

Get Started Free View All MCP Servers

Google Drive

featured

Google Drive is a cloud storage service

Available Tools:

google_drive_search_documents
google_drive_search_and_retrieve_documents
google_drive_get_file_tree_structure

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

Google Docs

featured

Google Docs is a word processor included as part of the free, web-based Google Docs Editors suite

Available Tools:

google_docs_get_document_by_id
google_docs_get_all_documents
google_docs_insert_text_at_end
+2 more tools

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

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"

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

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

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

# Get tools from all MCP servers
google_drive_tools = klavis_client.mcp_server.list_tools(
    server_url=google_drive_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
discord_tools = klavis_client.mcp_server.list_tools(
    server_url=discord_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
google_docs_tools = klavis_client.mcp_server.list_tools(
    server_url=google_docs_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)

# Combine all tools
all_tools = []
all_tools.extend(google_drive_tools)
all_tools.extend(discord_tools)
all_tools.extend(google_docs_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
)

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"

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

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

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

# Get tools from all MCP servers
google_drive_tools = klavis_client.mcp_server.list_tools(
    server_url=google_drive_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.ANTHROPIC,
)
discord_tools = klavis_client.mcp_server.list_tools(
    server_url=discord_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.ANTHROPIC,
)
google_docs_tools = klavis_client.mcp_server.list_tools(
    server_url=google_docs_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.ANTHROPIC,
)

# Combine all tools
all_tools = []
all_tools.extend(google_drive_tools.tools)
all_tools.extend(discord_tools.tools)
all_tools.extend(google_docs_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 google_driveMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.GoogleDrive,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

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

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

// Get tools from all MCP servers
const google_driveTools = await klavisClient.mcpServer.listTools({
    serverUrl: google_driveMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Anthropic,
});
const discordTools = await klavisClient.mcpServer.listTools({
    serverUrl: discordMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Anthropic,
});
const google_docsTools = await klavisClient.mcpServer.listTools({
    serverUrl: google_docsMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Anthropic,
});

// Combine all tools
const allTools = [
    ...google_driveTools.tools,
    ...discordTools.tools,
    ...google_docsTools.tools
];

const response = await anthropic.messages.create({
    model: CLAUDE_MODEL,
    max_tokens: 4000,
    messages: [{ 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"

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

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

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

# Get tools from all MCP servers
google_drive_tools = klavis_client.mcp_server.list_tools(
    server_url=google_drive_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.GEMINI,
)
discord_tools = klavis_client.mcp_server.list_tools(
    server_url=discord_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.GEMINI,
)
google_docs_tools = klavis_client.mcp_server.list_tools(
    server_url=google_docs_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.GEMINI,
)

# Combine all tools
all_tools = []
all_tools.extend(google_drive_tools.tools)
all_tools.extend(discord_tools.tools)
all_tools.extend(google_docs_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 google_driveMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.GoogleDrive,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

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

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

// Get tools from all MCP servers
const google_driveTools = await klavisClient.mcpServer.listTools({
    serverUrl: google_driveMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Gemini,
});
const discordTools = await klavisClient.mcpServer.listTools({
    serverUrl: discordMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Gemini,
});
const google_docsTools = await klavisClient.mcpServer.listTools({
    serverUrl: google_docsMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Gemini,
});

// Combine all tools
const allTools = [
    ...google_driveTools.tools,
    ...discordTools.tools,
    ...google_docsTools.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"))

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

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

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

mcp_client = MultiServerMCPClient({
    "google drive": {
        "transport": "streamable_http",
        "url": google_drive_mcp_instance.server_url
    },
    "discord": {
        "transport": "streamable_http",
        "url": discord_mcp_instance.server_url
    },
    "google docs": {
        "transport": "streamable_http",
        "url": google_docs_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 google_driveMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.GoogleDrive,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

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

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

const mcpClient = new MultiServerMCPClient({
    "google drive": {
        transport: "streamable_http",
        url: google_driveMcpInstance.serverUrl
    },
    "discord": {
        transport: "streamable_http",
        url: discordMcpInstance.serverUrl
    },
    "google docs": {
        transport: "streamable_http",
        url: google_docsMcpInstance.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"))

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

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

google_docs_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.GOOGLE_DOCS,
    user_id="1234",
    connection_type=ConnectionType.STREAMABLE_HTTP,
)
google_drive_tools = await aget_tools_from_mcp_url(
    google_drive_mcp_instance.server_url, 
    client=BasicMCPClient(google_drive_mcp_instance.server_url)
)
discord_tools = await aget_tools_from_mcp_url(
    discord_mcp_instance.server_url, 
    client=BasicMCPClient(discord_mcp_instance.server_url)
)
google_docs_tools = await aget_tools_from_mcp_url(
    google_docs_mcp_instance.server_url, 
    client=BasicMCPClient(google_docs_mcp_instance.server_url)
)

google_drive_agent = FunctionAgent(
    name="google_drive_agent",
    tools=google_drive_tools,
    llm=llm,
)

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

google_docs_agent = FunctionAgent(
    name="google_docs_agent",
    tools=google_docs_tools,
    llm=llm,
)
workflow = AgentWorkflow(
    agents=[google_drive_agent, discord_agent, google_docs_agent],
    root_agent="google_drive_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 google_driveMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.GoogleDrive,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

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

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

// Create MCP server connections
const google_driveServer = mcp({
    url: google_driveMcpInstance.serverUrl,
    verbose: true,
});
const discordServer = mcp({
    url: discordMcpInstance.serverUrl,
    verbose: true,
});
const google_docsServer = mcp({
    url: google_docsMcpInstance.serverUrl,
    verbose: true,
});

// Get tools from MCP servers
const google_driveTools = await google_driveServer.tools();
const discordTools = await discordServer.tools();
const google_docsTools = await google_docsServer.tools();

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

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

const google_docsAgent = agent({
    name: "google_docs_agent",
    llm: openai({ model: "gpt-4o" }),
    tools: google_docsTools,
});

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

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

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

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

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

# Initialize MCP tools for each server
google_drive_tools = MCPServerAdapter(google_drive_mcp_instance.server_params)
discord_tools = MCPServerAdapter(discord_mcp_instance.server_params)
google_docs_tools = MCPServerAdapter(google_docs_mcp_instance.server_params)

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

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
)

google_docs_agent = Agent(
    role="Google Docs Specialist",
    goal="Handle all Google Docs related tasks and data processing",
    backstory="You are an expert in Google Docs operations and data analysis",
    tools=google_docs_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=google_drive_agent,
    markdown=True
)

# Create multi-agent crew
crew = Crew(
    agents=[google_drive_agent, discord_agent, google_docs_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"))

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

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

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

# Get all MCP tools
google_drive_tools = klavis_client.mcp_server.list_tools(
    server_url=google_drive_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
discord_tools = klavis_client.mcp_server.list_tools(
    server_url=discord_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
google_docs_tools = klavis_client.mcp_server.list_tools(
    server_url=google_docs_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)

# Combine all tools
all_tools = []
all_tools.extend(google_drive_tools.tools)
all_tools.extend(discord_tools.tools)
all_tools.extend(google_docs_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 google_driveMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.GoogleDrive,
    userId: "1234",
    platformName: "Klavis",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

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

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

// Get all MCP tools
const google_driveTools = await klavisClient.mcpServer.listTools({
    serverUrl: google_driveMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});
const discordTools = await klavisClient.mcpServer.listTools({
    serverUrl: discordMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});
const google_docsTools = await klavisClient.mcpServer.listTools({
    serverUrl: google_docsMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});

// Combine all tools
const allTools = [
    ...google_driveTools.tools,
    ...discordTools.tools,
    ...google_docsTools.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"))

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

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

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

# Get all MCP tools
google_drive_tools = klavis_client.mcp_server.list_tools(
    server_url=google_drive_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
discord_tools = klavis_client.mcp_server.list_tools(
    server_url=discord_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
google_docs_tools = klavis_client.mcp_server.list_tools(
    server_url=google_docs_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)

# Combine all tools
all_tools = []
all_tools.extend(google_drive_tools.tools)
all_tools.extend(discord_tools.tools)
all_tools.extend(google_docs_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 google_driveMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.GoogleDrive,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

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

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

// Get all MCP tools
const google_driveTools = await klavisClient.mcpServer.listTools({
    serverUrl: google_driveMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});
const discordTools = await klavisClient.mcpServer.listTools({
    serverUrl: discordMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});
const google_docsTools = await klavisClient.mcpServer.listTools({
    serverUrl: google_docsMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});

// Combine all tools
const allTools = [
    ...google_driveTools.tools,
    ...discordTools.tools,
    ...google_docsTools.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

ConnectOpenAIto Google Drive, Discord, Google Docs MCP Servers

Google Drive

Available Tools:

Discord

Available Tools:

Google Docs

Available Tools:

Quick Setup Guide

Create Your Account

Configure Connections

Test & Deploy

Integrate in minutes, Scale to millions

Frequently Asked Questions

Ready to Get Started?

Connectto Google Drive, Discord, Google Docs MCP Servers