How do I use multiple MCP servers (Outlook, Gmail, Google Docs) with Fireworks AI?

Fireworks AI supports connecting to multiple MCP servers simultaneously. You can configure each Outlook, Gmail, Google Docs server independently and use their tools together in your AI applications. This enables powerful multi-source AI systems where your models can access data from Outlook, Gmail, Google Docs and combine insights for comprehensive responses. Klavis AI simplifies multi-server management with centralized configuration and unified connection handling for Fireworks AI applications.

What are the benefits of using Outlook and Gmail and Google Docs together with Fireworks AI?

Combining Outlook and Gmail and Google Docs with your Fireworks AI applications creates powerful synergies for advanced AI systems. Each service brings unique data sources and capabilities that complement each other, enabling comprehensive information retrieval, cross-platform data correlation, and enhanced AI responses with multi-source validation using Fireworks AI's high-performance inference.

Do I need special packages for Fireworks AI MCP server integration?

Yes, you'll need the Fireworks AI SDK and any service-specific packages for the MCP servers you want to connect to. Klavis AI provides detailed package requirements and automated installation scripts for each supported MCP server, along with Fireworks AI-specific configuration examples and troubleshooting guides to ensure smooth setup.

Can I use function calling with Fireworks AI and MCP servers?

Absolutely! MCP servers are designed to work seamlessly with Fireworks AI's function calling capabilities. You can use MCP server tools with any Fireworks AI model that supports function calling, allowing your AI models to perform actions and retrieve data from external services as part of their reasoning and response generation process.

How do I handle authentication for MCP servers with Fireworks AI?

Authentication for MCP servers with Fireworks AI is handled through environment variables and configuration files. Each MCP server may require different authentication methods (API keys, OAuth tokens, etc.). Klavis AI handles the authentication flow automatically once you provide the necessary credentials, and provides secure credential management, encrypted storage, and pre-configured authentication templates for all supported services.

Which Fireworks AI models are best for these MCP servers?

For these MCP servers, we recommend using Fireworks AI models with strong function calling capabilities such as Llama 3.1 70B, Mixtral 8x7B, or Code Llama for coding tasks. These models provide excellent performance for tool use and can effectively leverage the capabilities of external MCP servers. Klavis AI provides model-specific optimization guides and performance benchmarks to help you choose the best Fireworks AI model for your use case.

What types of AI applications benefit most from Fireworks AI + MCP server integration?

AI applications that benefit most include: chatbots and virtual assistants needing real-time data access, automated workflow systems that interact with multiple platforms, content generation tools that need to pull data from various sources, and AI agents that perform complex multi-step tasks. Fireworks AI's high-performance inference combined with MCP servers extends your applications beyond static responses to dynamic, real-time AI interactions.

How does MCP server integration affect Fireworks AI performance?

MCP server integration adds minimal latency when properly configured, thanks to Fireworks AI's optimized inference and efficient function calling. The impact is typically negligible compared to the enhanced capabilities gained. Best practices include caching frequently accessed data, using appropriate timeouts, and implementing fallback strategies for when external services are unavailable. Klavis AI provides performance monitoring tools and optimization recommendations to ensure your Fireworks AI + MCP server applications run at peak efficiency.

Can I use streaming responses with Fireworks AI and MCP servers?

Yes, Fireworks AI's streaming capabilities work well with MCP server integrations. You can stream AI responses while making function calls to MCP servers, providing a smooth user experience. The streaming continues after function calls are completed, allowing for real-time updates and interactive AI experiences. Klavis AI provides examples and best practices for implementing streaming with MCP server function calls.

Why choose Klavis AI for Fireworks AI MCP server connections?

Klavis AI provides the most comprehensive platform for Fireworks AI MCP server integration with features like pre-built Fireworks AI connectors, automated setup scripts, detailed documentation with Fireworks AI-specific examples, secure credential management, and performance optimization guides. Our platform is specifically designed to make Fireworks AI + MCP server integration as seamless as possible for developers building advanced AI applications. With Klavis AI's centralized management dashboard, you can monitor all your MCP server connections, track performance metrics, analyze function call usage, and troubleshoot issues from a single interface.

Connectto Outlook, Gmail, Google Docs MCP Servers

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

Get Started Free View All MCP Servers

Outlook

featured

Outlook Mail is a web-based suite of webmail, contacts, tasks, and calendaring services from Microsoft

Gmail

featured

Gmail is a free email service provided by Google

Available Tools:

gmail_send_email
gmail_draft_email
gmail_read_email
+5 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 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"))

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

gmail_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.GMAIL,
    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
outlook_tools = klavis_client.mcp_server.list_tools(
    server_url=outlook_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
gmail_tools = klavis_client.mcp_server.list_tools(
    server_url=gmail_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(outlook_tools.tools)
all_tools.extend(gmail_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
)

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"

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

gmail_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.GMAIL,
    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
outlook_tools = klavis_client.mcp_server.list_tools(
    server_url=outlook_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.ANTHROPIC,
)
gmail_tools = klavis_client.mcp_server.list_tools(
    server_url=gmail_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(outlook_tools.tools)
all_tools.extend(gmail_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 outlookMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Outlook,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const gmailMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Gmail,
    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 outlookTools = await klavisClient.mcpServer.listTools({
    serverUrl: outlookMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Anthropic,
});
const gmailTools = await klavisClient.mcpServer.listTools({
    serverUrl: gmailMcpInstance.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 = [
    ...outlookTools.tools,
    ...gmailTools.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 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"

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

gmail_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.GMAIL,
    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
outlook_tools = klavis_client.mcp_server.list_tools(
    server_url=outlook_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
gmail_tools = klavis_client.mcp_server.list_tools(
    server_url=gmail_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(outlook_tools)
all_tools.extend(gmail_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
)

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 outlookMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Outlook,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const gmailMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Gmail,
    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 outlookTools = await klavisClient.mcpServer.listTools({
    serverUrl: outlookMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});
const gmailTools = await klavisClient.mcpServer.listTools({
    serverUrl: gmailMcpInstance.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 = [
    ...outlookTools,
    ...gmailTools,
    ...google_docsTools
];

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"

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

gmail_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.GMAIL,
    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
outlook_tools = klavis_client.mcp_server.list_tools(
    server_url=outlook_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.GEMINI,
)
gmail_tools = klavis_client.mcp_server.list_tools(
    server_url=gmail_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(outlook_tools.tools)
all_tools.extend(gmail_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 outlookMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Outlook,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const gmailMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Gmail,
    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 outlookTools = await klavisClient.mcpServer.listTools({
    serverUrl: outlookMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Gemini,
});
const gmailTools = await klavisClient.mcpServer.listTools({
    serverUrl: gmailMcpInstance.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 = [
    ...outlookTools.tools,
    ...gmailTools.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"))

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

gmail_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.GMAIL,
    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({
    "outlook": {
        "transport": "streamable_http",
        "url": outlook_mcp_instance.server_url
    },
    "gmail": {
        "transport": "streamable_http",
        "url": gmail_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 outlookMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Outlook,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const gmailMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Gmail,
    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({
    "outlook": {
        transport: "streamable_http",
        url: outlookMcpInstance.serverUrl
    },
    "gmail": {
        transport: "streamable_http",
        url: gmailMcpInstance.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"))

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

gmail_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.GMAIL,
    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,
)
outlook_tools = await aget_tools_from_mcp_url(
    outlook_mcp_instance.server_url, 
    client=BasicMCPClient(outlook_mcp_instance.server_url)
)
gmail_tools = await aget_tools_from_mcp_url(
    gmail_mcp_instance.server_url, 
    client=BasicMCPClient(gmail_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)
)

outlook_agent = FunctionAgent(
    name="outlook_agent",
    tools=outlook_tools,
    llm=llm,
)

gmail_agent = FunctionAgent(
    name="gmail_agent",
    tools=gmail_tools,
    llm=llm,
)

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

const gmailMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Gmail,
    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 outlookServer = mcp({
    url: outlookMcpInstance.serverUrl,
    verbose: true,
});
const gmailServer = mcp({
    url: gmailMcpInstance.serverUrl,
    verbose: true,
});
const google_docsServer = mcp({
    url: google_docsMcpInstance.serverUrl,
    verbose: true,
});

// Get tools from MCP servers
const outlookTools = await outlookServer.tools();
const gmailTools = await gmailServer.tools();
const google_docsTools = await google_docsServer.tools();

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

const gmailAgent = agent({
    name: "gmail_agent",
    llm: openai({ model: "gpt-4o" }),
    tools: gmailTools,
});

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

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

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

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

gmail_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.GMAIL,
    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
outlook_tools = MCPServerAdapter(outlook_mcp_instance.server_params)
gmail_tools = MCPServerAdapter(gmail_mcp_instance.server_params)
google_docs_tools = MCPServerAdapter(google_docs_mcp_instance.server_params)

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

gmail_agent = Agent(
    role="Gmail Specialist",
    goal="Handle all Gmail related tasks and data processing",
    backstory="You are an expert in Gmail operations and data analysis",
    tools=gmail_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=outlook_agent,
    markdown=True
)

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

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

gmail_mcp_instance = klavis_client.mcp_server.create_server_instance(
    server_name=McpServerName.GMAIL,
    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
outlook_tools = klavis_client.mcp_server.list_tools(
    server_url=outlook_mcp_instance.server_url,
    connection_type=ConnectionType.STREAMABLE_HTTP,
    format=ToolFormat.OPENAI,
)
gmail_tools = klavis_client.mcp_server.list_tools(
    server_url=gmail_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(outlook_tools.tools)
all_tools.extend(gmail_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 outlookMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Outlook,
    userId: "1234",
    connectionType: Klavis.ConnectionType.StreamableHttp,
});

const gmailMcpInstance = await klavisClient.mcpServer.createServerInstance({
    serverName: Klavis.McpServerName.Gmail,
    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 outlookTools = await klavisClient.mcpServer.listTools({
    serverUrl: outlookMcpInstance.serverUrl,
    connectionType: Klavis.ConnectionType.StreamableHttp,
    format: Klavis.ToolFormat.Openai,
});
const gmailTools = await klavisClient.mcpServer.listTools({
    serverUrl: gmailMcpInstance.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 = [
    ...outlookTools.tools,
    ...gmailTools.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

ConnectFireworks AIto Outlook, Gmail, Google Docs MCP Servers

Outlook

Gmail

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 Outlook, Gmail, Google Docs MCP Servers