Connectto Asana, Jira, Slack MCP Servers
Create powerful AI workflows by connecting multiple MCP servers including Asana, Jira, Slack for enhanced automation capabilities in Klavis AI.
Asana
featured
Asana is a web and mobile application designed to help teams organize, track, and manage their work. It provides project management tools, task assignment, collaboration features, and progress tracking to boost team productivity
Available Tools:
- asana_create_task
- asana_get_task
- asana_search_tasks
- +16 more tools
Jira
featured
Jira is a project management and issue tracking tool developed by Atlassian
Available Tools:
- jira_search
- jira_get_issue
- jira_search_fields
- +11 more tools
Slack
featured
Slack is a messaging app for business that connects people to the information they need
Available Tools:
- slack_user_list_channels
- slack_get_channel_history
- slack_invite_users_to_channel
- +9 more tools
Quick Setup Guide
Follow these steps to connect your AI agents to these MCP servers
1
Create Your Account
Sign up for KlavisAI to access our MCP server management platform.
2
Configure Connections
Add your desired MCP servers to your AI client and configure authentication settings.
3
Test & Deploy
Verify your connections work correctly and start using your enhanced AI capabilities.
Integrate in minutes, Scale to millions
View Documentationimport 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"))
asana_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.ASANA,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
jira_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.JIRA,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
slack_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.SLACK,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
# Get all MCP tools
asana_tools = klavis_client.mcp_server.list_tools(
server_url=asana_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.OPENAI,
)
jira_tools = klavis_client.mcp_server.list_tools(
server_url=jira_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.OPENAI,
)
slack_tools = klavis_client.mcp_server.list_tools(
server_url=slack_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.OPENAI,
)
# Combine all tools
all_tools = []
all_tools.extend(asana_tools.tools)
all_tools.extend(jira_tools.tools)
all_tools.extend(slack_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
)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"
asana_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.ASANA,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
jira_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.JIRA,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
slack_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.SLACK,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
# Get tools from all MCP servers
asana_tools = klavis_client.mcp_server.list_tools(
server_url=asana_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.ANTHROPIC,
)
jira_tools = klavis_client.mcp_server.list_tools(
server_url=jira_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.ANTHROPIC,
)
slack_tools = klavis_client.mcp_server.list_tools(
server_url=slack_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.ANTHROPIC,
)
# Combine all tools
all_tools = []
all_tools.extend(asana_tools.tools)
all_tools.extend(jira_tools.tools)
all_tools.extend(slack_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 asanaMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Asana,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
const jiraMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Jira,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
const slackMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Slack,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
// Get tools from all MCP servers
const asanaTools = await klavisClient.mcpServer.listTools({
serverUrl: asanaMcpInstance.serverUrl,
connectionType: Klavis.ConnectionType.StreamableHttp,
format: Klavis.ToolFormat.Anthropic,
});
const jiraTools = await klavisClient.mcpServer.listTools({
serverUrl: jiraMcpInstance.serverUrl,
connectionType: Klavis.ConnectionType.StreamableHttp,
format: Klavis.ToolFormat.Anthropic,
});
const slackTools = await klavisClient.mcpServer.listTools({
serverUrl: slackMcpInstance.serverUrl,
connectionType: Klavis.ConnectionType.StreamableHttp,
format: Klavis.ToolFormat.Anthropic,
});
// Combine all tools
const allTools = [
...asanaTools.tools,
...jiraTools.tools,
...slackTools.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"
asana_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.ASANA,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
jira_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.JIRA,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
slack_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.SLACK,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
# Get tools from all MCP servers
asana_tools = klavis_client.mcp_server.list_tools(
server_url=asana_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.OPENAI,
)
jira_tools = klavis_client.mcp_server.list_tools(
server_url=jira_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.OPENAI,
)
slack_tools = klavis_client.mcp_server.list_tools(
server_url=slack_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.OPENAI,
)
# Combine all tools
all_tools = []
all_tools.extend(asana_tools)
all_tools.extend(jira_tools)
all_tools.extend(slack_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 asanaMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Asana,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
const jiraMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Jira,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
const slackMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Slack,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
// Get tools from all MCP servers
const asanaTools = await klavisClient.mcpServer.listTools({
serverUrl: asanaMcpInstance.serverUrl,
connectionType: Klavis.ConnectionType.StreamableHttp,
format: Klavis.ToolFormat.Openai,
});
const jiraTools = await klavisClient.mcpServer.listTools({
serverUrl: jiraMcpInstance.serverUrl,
connectionType: Klavis.ConnectionType.StreamableHttp,
format: Klavis.ToolFormat.Openai,
});
const slackTools = await klavisClient.mcpServer.listTools({
serverUrl: slackMcpInstance.serverUrl,
connectionType: Klavis.ConnectionType.StreamableHttp,
format: Klavis.ToolFormat.Openai,
});
// Combine all tools
const allTools = [
...asanaTools,
...jiraTools,
...slackTools
];
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"
asana_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.ASANA,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
jira_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.JIRA,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
slack_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.SLACK,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
# Get tools from all MCP servers
asana_tools = klavis_client.mcp_server.list_tools(
server_url=asana_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.GEMINI,
)
jira_tools = klavis_client.mcp_server.list_tools(
server_url=jira_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.GEMINI,
)
slack_tools = klavis_client.mcp_server.list_tools(
server_url=slack_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.GEMINI,
)
# Combine all tools
all_tools = []
all_tools.extend(asana_tools.tools)
all_tools.extend(jira_tools.tools)
all_tools.extend(slack_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 asanaMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Asana,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
const jiraMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Jira,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
const slackMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Slack,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
// Get tools from all MCP servers
const asanaTools = await klavisClient.mcpServer.listTools({
serverUrl: asanaMcpInstance.serverUrl,
connectionType: Klavis.ConnectionType.StreamableHttp,
format: Klavis.ToolFormat.Gemini,
});
const jiraTools = await klavisClient.mcpServer.listTools({
serverUrl: jiraMcpInstance.serverUrl,
connectionType: Klavis.ConnectionType.StreamableHttp,
format: Klavis.ToolFormat.Gemini,
});
const slackTools = await klavisClient.mcpServer.listTools({
serverUrl: slackMcpInstance.serverUrl,
connectionType: Klavis.ConnectionType.StreamableHttp,
format: Klavis.ToolFormat.Gemini,
});
// Combine all tools
const allTools = [
...asanaTools.tools,
...jiraTools.tools,
...slackTools.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"))
asana_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.ASANA,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
jira_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.JIRA,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
slack_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.SLACK,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
mcp_client = MultiServerMCPClient({
"asana": {
"transport": "streamable_http",
"url": asana_mcp_instance.server_url
},
"jira": {
"transport": "streamable_http",
"url": jira_mcp_instance.server_url
},
"slack": {
"transport": "streamable_http",
"url": slack_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 asanaMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Asana,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
const jiraMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Jira,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
const slackMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Slack,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
const mcpClient = new MultiServerMCPClient({
"asana": {
transport: "streamable_http",
url: asanaMcpInstance.serverUrl
},
"jira": {
transport: "streamable_http",
url: jiraMcpInstance.serverUrl
},
"slack": {
transport: "streamable_http",
url: slackMcpInstance.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"))
asana_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.ASANA,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
jira_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.JIRA,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
slack_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.SLACK,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
asana_tools = await aget_tools_from_mcp_url(
asana_mcp_instance.server_url,
client=BasicMCPClient(asana_mcp_instance.server_url)
)
jira_tools = await aget_tools_from_mcp_url(
jira_mcp_instance.server_url,
client=BasicMCPClient(jira_mcp_instance.server_url)
)
slack_tools = await aget_tools_from_mcp_url(
slack_mcp_instance.server_url,
client=BasicMCPClient(slack_mcp_instance.server_url)
)
asana_agent = FunctionAgent(
name="asana_agent",
tools=asana_tools,
llm=llm,
)
jira_agent = FunctionAgent(
name="jira_agent",
tools=jira_tools,
llm=llm,
)
slack_agent = FunctionAgent(
name="slack_agent",
tools=slack_tools,
llm=llm,
)
workflow = AgentWorkflow(
agents=[asana_agent, jira_agent, slack_agent],
root_agent="asana_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 asanaMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Asana,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
const jiraMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Jira,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
const slackMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Slack,
userId: "1234",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
// Create MCP server connections
const asanaServer = mcp({
url: asanaMcpInstance.serverUrl,
verbose: true,
});
const jiraServer = mcp({
url: jiraMcpInstance.serverUrl,
verbose: true,
});
const slackServer = mcp({
url: slackMcpInstance.serverUrl,
verbose: true,
});
// Get tools from MCP servers
const asanaTools = await asanaServer.tools();
const jiraTools = await jiraServer.tools();
const slackTools = await slackServer.tools();
// Create specialized agents
const asanaAgent = agent({
name: "asana_agent",
llm: openai({ model: "gpt-4o" }),
tools: asanaTools,
});
const jiraAgent = agent({
name: "jira_agent",
llm: openai({ model: "gpt-4o" }),
tools: jiraTools,
});
const slackAgent = agent({
name: "slack_agent",
llm: openai({ model: "gpt-4o" }),
tools: slackTools,
});
// Create multi-agent workflow
const agents = multiAgent({
agents: [asanaAgent, jiraAgent, slackAgent],
rootAgent: asanaAgent,
});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"))
asana_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.ASANA,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
jira_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.JIRA,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
slack_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.SLACK,
user_id="1234",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
# Initialize MCP tools for each server
asana_tools = MCPServerAdapter(asana_mcp_instance.server_params)
jira_tools = MCPServerAdapter(jira_mcp_instance.server_params)
slack_tools = MCPServerAdapter(slack_mcp_instance.server_params)
# Create specialized agents for each service
asana_agent = Agent(
role="Asana Specialist",
goal="Handle all Asana related tasks and data processing",
backstory="You are an expert in Asana operations and data analysis",
tools=asana_tools,
reasoning=True,
verbose=False
)
jira_agent = Agent(
role="Jira Specialist",
goal="Handle all Jira related tasks and data processing",
backstory="You are an expert in Jira operations and data analysis",
tools=jira_tools,
reasoning=True,
verbose=False
)
slack_agent = Agent(
role="Slack Specialist",
goal="Handle all Slack related tasks and data processing",
backstory="You are an expert in Slack operations and data analysis",
tools=slack_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=asana_agent,
markdown=True
)
# Create multi-agent crew
crew = Crew(
agents=[asana_agent, jira_agent, slack_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"))
asana_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.ASANA,
user_id="1234",
platform_name="Klavis",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
jira_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.JIRA,
user_id="1234",
platform_name="Klavis",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
slack_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.SLACK,
user_id="1234",
platform_name="Klavis",
connection_type=ConnectionType.STREAMABLE_HTTP,
)
# Get all MCP tools
asana_tools = klavis_client.mcp_server.list_tools(
server_url=asana_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.OPENAI,
)
jira_tools = klavis_client.mcp_server.list_tools(
server_url=jira_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.OPENAI,
)
slack_tools = klavis_client.mcp_server.list_tools(
server_url=slack_mcp_instance.server_url,
connection_type=ConnectionType.STREAMABLE_HTTP,
format=ToolFormat.OPENAI,
)
# Combine all tools
all_tools = []
all_tools.extend(asana_tools.tools)
all_tools.extend(jira_tools.tools)
all_tools.extend(slack_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 asanaMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Asana,
userId: "1234",
platformName: "Klavis",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
const jiraMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Jira,
userId: "1234",
platformName: "Klavis",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
const slackMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Slack,
userId: "1234",
platformName: "Klavis",
connectionType: Klavis.ConnectionType.StreamableHttp,
});
// Get all MCP tools
const asanaTools = await klavisClient.mcpServer.listTools({
serverUrl: asanaMcpInstance.serverUrl,
connectionType: Klavis.ConnectionType.StreamableHttp,
format: Klavis.ToolFormat.Openai,
});
const jiraTools = await klavisClient.mcpServer.listTools({
serverUrl: jiraMcpInstance.serverUrl,
connectionType: Klavis.ConnectionType.StreamableHttp,
format: Klavis.ToolFormat.Openai,
});
const slackTools = await klavisClient.mcpServer.listTools({
serverUrl: slackMcpInstance.serverUrl,
connectionType: Klavis.ConnectionType.StreamableHttp,
format: Klavis.ToolFormat.Openai,
});
// Combine all tools
const allTools = [
...asanaTools.tools,
...jiraTools.tools,
...slackTools.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,
});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