# Claude
Source: https://www.klavis.ai/docs/ai-platform-integration/claude
Learn how to build AI agents that integrate Anthropic's Claude with Strata MCP servers to build AI agents that can interact with Gmail and Slack.
[](https://colab.research.google.com/github/klavis-ai/klavis/blob/main/examples/claude/Use_Klavis_with_Claude.ipynb)
## Prerequisites
Before we begin, you'll need:
Get your API key from Anthropic Console
Get your API key from Klavis AI
## Installation
First, install the required packages:
```bash Python theme={null}
pip install anthropic klavis
```
```bash TypeScript theme={null}
npm install @anthropic-ai/sdk klavis
```
## Setup Environment Variables
```python Python theme={null}
import os
os.environ["ANTHROPIC_API_KEY"] = "YOUR_ANTHROPIC_API_KEY" # Replace with your actual Anthropic API key
os.environ["KLAVIS_API_KEY"] = "YOUR_KLAVIS_API_KEY" # Replace with your actual Klavis API key
```
```typescript TypeScript theme={null}
import Anthropic from '@anthropic-ai/sdk';
import { KlavisClient, Klavis } from 'klavis';
// Set environment variables
process.env.ANTHROPIC_API_KEY = "YOUR_ANTHROPIC_API_KEY"; // Replace with your actual Anthropic API key
process.env.KLAVIS_API_KEY = "YOUR_KLAVIS_API_KEY"; // Replace with your actual Klavis API key
```
### Step 1 - Create Strata MCP Server with Gmail and Slack
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName, ToolFormat
import webbrowser
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GMAIL, McpServerName.SLACK],
user_id="1234"
)
# Handle OAuth authorization for each services
if response.oauth_urls:
for server_name, oauth_url in response.oauth_urls.items():
webbrowser.open(oauth_url)
print(f"Or please open this URL to complete {server_name} OAuth authorization: {oauth_url}")
```
```typescript TypeScript theme={null}
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });
const response = await klavisClient.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Gmail, Klavis.McpServerName.Slack],
userId: "1234"
});
// Handle OAuth authorization for each services
if (response.oauthUrls) {
for (const [serverName, oauthUrl] of Object.entries(response.oauthUrls)) {
window.open(oauthUrl);
// Wait for user to complete OAuth
await new Promise(resolve => {
const input = prompt(`Press OK after completing ${serverName} OAuth authorization...`);
resolve(input);
});
}
}
```
**OAuth Authorization Required**: The code above will open browser windows for each service. Click through the OAuth flow to authorize access to your accounts.
### Step 2 - Create method to use MCP Server with Claude
This method handles multiple rounds of tool calls until a final response is ready, allowing the AI to chain tool executions for complex tasks.
```python Python theme={null}
import json
from anthropic import Anthropic
def claude_with_mcp_server(mcp_server_url: str, user_query: str):
claude_client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
messages = [
{"role": "user", "content": f"{user_query}"}
]
mcp_server_tools = klavis_client.mcp_server.list_tools(
server_url=mcp_server_url,
format=ToolFormat.ANTHROPIC
)
max_iterations = 10
iteration = 0
while iteration < max_iterations:
iteration += 1
response = claude_client.messages.create(
model="claude-sonnet-4-5-20250929",
max_tokens=4000,
system="You are a helpful assistant. Use the available tools to answer the user's question.",
messages=messages,
tools=mcp_server_tools.tools
)
messages.append({"role": "assistant", "content": response.content})
if response.stop_reason == "tool_use":
tool_results = []
for content_block in response.content:
if content_block.type == "tool_use":
function_name = content_block.name
function_args = content_block.input
print(f"š§ Calling: {function_name}, with args: {function_args}")
result = klavis_client.mcp_server.call_tools(
server_url=mcp_server_url,
tool_name=function_name,
tool_args=function_args
)
tool_results.append({
"type": "tool_result",
"tool_use_id": content_block.id,
"content": str(result)
})
messages.append({"role": "user", "content": tool_results})
continue
else:
return response.content[0].text
return "Max iterations reached without final response"
```
```typescript TypeScript theme={null}
async function claudeWithMcpServer(mcpServerUrl: string, userQuery: string) {
const claudeClient = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
const messages = [
{ role: "user", content: userQuery }
];
const mcpServerTools = await klavisClient.mcpServer.listTools({
serverUrl: mcpServerUrl,
format: Klavis.ToolFormat.Anthropic
});
const maxIterations = 10;
let iteration = 0;
while (iteration < maxIterations) {
iteration++;
const response = await claudeClient.messages.create({
model: "claude-sonnet-4-5-20250929",
max_tokens: 4000,
system: "You are a helpful assistant. Use the available tools to answer the user's question.",
messages: messages,
tools: mcpServerTools.tools
});
messages.push({ role: "assistant", content: response.content });
if (response.stop_reason === "tool_use") {
const toolResults = [];
for (const contentBlock of response.content) {
if (contentBlock.type === "tool_use") {
const functionName = contentBlock.name;
const functionArgs = contentBlock.input;
console.log(`š§ Calling: ${functionName}, with args:`, functionArgs);
const result = await klavisClient.mcpServer.callTools({
serverUrl: mcpServerUrl,
toolName: functionName,
toolArgs: functionArgs
});
toolResults.push({
type: "tool_result",
tool_use_id: contentBlock.id,
content: JSON.stringify(result)
});
}
}
messages.push({ role: "user", content: toolResults });
continue;
} else {
return response.content[0].text;
}
}
return "Max iterations reached without final response";
}
```
### Step 3 - Run!
```python Python theme={null}
result = claude_with_mcp_server(
mcp_server_url=response.strata_server_url,
user_query="Check my latest 5 emails and summarize them in a Slack message to #general"
)
print(f"\nš¤ Final Response: {result}")
```
```typescript TypeScript theme={null}
result = await claudeWithMcpServer(
response.strataServerUrl,
"Check my latest emails and summarize them in a Slack message to #updates"
);
console.log(`\nš¤ Final Response: ${result}`);
```
Perfect! You've integrated Claude with Klavis MCP servers.
## Next Steps
Explore available MCP servers
REST endpoints and schemas
## Useful Resources
* [Anthropic API Documentation](https://docs.anthropic.com/)
* [Claude API Reference](https://docs.anthropic.com/en/api/messages)
* [MCP Protocol Specification](https://modelcontextprotocol.io/)
**Happy building!** š
# CrewAI
Source: https://www.klavis.ai/docs/ai-platform-integration/crewai
Build powerful AI agent crews that integrate with Strata MCP servers to build AI agents that can interact with Gmail and Slack.
## Partnership
CrewAI has officially showcased their integration with Klavis AI in [this LinkedIn post](https://www.linkedin.com/feed/update/urn:li:activity:7346573584267395072/), demonstrating how to build powerful AI agent crews that can automate complex workflows across multiple platforms.
## Prerequisites
Before we begin, you'll need:
Get your API key from OpenAI Platform (CrewAI uses OpenAI as the default model)
Get your API key from Klavis AI
## Installation
First, install the required packages:
```bash Python theme={null}
pip install crewai 'crewai-tools[mcp]' klavis openai
```
```bash TypeScript theme={null}
npm install crewai crewai-tools klavis openai
```
## Setup Environment Variables
```python Python theme={null}
import os
# Set environment variables
os.environ["OPENAI_API_KEY"] = "your-openai-api-key-here" # Replace with your actual OpenAI API key
os.environ["KLAVIS_API_KEY"] = "your-klavis-api-key-here" # Replace with your actual Klavis API key
```
```typescript TypeScript theme={null}
// Set environment variables in your .env file
process.env.OPENAI_API_KEY = "your-openai-api-key-here"; // Replace with your actual OpenAI API key
process.env.KLAVIS_API_KEY = "your-klavis-api-key-here"; // Replace with your actual Klavis API key
```
## CrewAI with MCP Integration
CrewAI allows you to create specialized AI agent crews where each agent can have access to different MCP tools. This enables sophisticated multi-agent workflows that can:
1. **Create MCP Instances**: Set up connections to external services
2. **Specialized Agents**: Each agent focuses on specific tasks with relevant tools
3. **Collaborative Workflows**: Agents work together in sequential or parallel processes
4. **Tool Discovery**: Automatically discover available tools from MCP servers
5. **Smart Coordination**: CrewAI manages task dependencies and agent collaboration
## Crew AI + Klavis Strata
Create a crew agent that helps in assisting user queries using Strata Server
### Step 1 - Create Strata MCP Server with Gmail and Slack
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName, ToolFormat
import webbrowser
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GMAIL, McpServerName.SLACK],
user_id="1234"
)
# Handle OAuth authorization for each services
if response.oauth_urls:
for server_name, oauth_url in response.oauth_urls.items():
webbrowser.open(oauth_url)
print(f"Or please open this URL to complete {server_name} OAuth authorization: {oauth_url}")
```
```typescript TypeScript theme={null}
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });
const response = await klavisClient.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Gmail, Klavis.McpServerName.Slack],
userId: "1234"
});
// Handle OAuth authorization for each services
if (response.oauthUrls) {
for (const [serverName, oauthUrl] of Object.entries(response.oauthUrls)) {
window.open(oauthUrl);
// Wait for user to complete OAuth
await new Promise(resolve => {
const input = prompt(`Press OK after completing ${serverName} OAuth authorization...`);
resolve(input);
});
}
}
```
**OAuth Authorization Required**: The code above will open browser windows for each service. Click through the OAuth flow to authorize access to your accounts.
### Step 2 - Create method to use MCP Server with Crew AI
This method handles multiple rounds of tool calls until a final response is ready, allowing the AI to chain tool executions for complex tasks.
```python Python theme={null}
import json
from crewai import Agent, Task, Crew, Process
from crewai_tools import MCPServerAdapter
def crew_with_mcp_server(mcp_server_url: str, user_query: str):
klavis_server_params = [
{
"url": mcp_server_url,
"transport": "streamable-http"
}
]
with MCPServerAdapter(klavis_server_params) as all_mcp_tools:
print(f"Available tools: {[tool.name for tool in all_mcp_tools]}")
klavis_agent = Agent(
role="Klavis Query Assistant",
goal="Assist the user with their query using available tools",
backstory="Expert at assisting users with their queries using available tools",
tools=all_mcp_tools,
verbose=False,
llm="gpt-4o"
)
klavis_task = Task(
description=f"Answer the user's query: {user_query}",
expected_output="Provide a detailed response to the user's query",
agent=klavis_agent
)
crew = Crew(
agents = [klavis_agent],
tasks = [klavis_task],
process=Process.sequential,
verbose=True
)
result = crew.kickoff()
return result
```
```typescript TypeScript theme={null}
import { Agent, Task, Crew, Process } from 'crewai';
import { MCPServerAdapter } from 'crewai-tools';
async function crewWithMcpServer(mcpServerUrl: string, userQuery: string) {
const klavisServerParams = [
{
url: mcpServerUrl,
transport: "streamable-http"
}
];
const mcpAdapter = new MCPServerAdapter(klavisServerParams);
const allMcpTools = await mcpAdapter.getTools();
console.log(`Available tools: ${allMcpTools.map(tool => tool.name)}`);
const klavisAgent = new Agent({
role: "Klavis Query Assistant",
goal: "Assist the user with their query using available tools",
backstory: "Expert at assisting users with their queries using available tools",
tools: allMcpTools,
verbose: false,
llm: "gpt-4o"
});
const klavisTask = new Task({
description: `Answer the user's query: ${userQuery}`,
expectedOutput: "Provide a detailed response to the user's query",
agent: klavisAgent
});
const crew = new Crew({
agents: [klavisAgent],
tasks: [klavisTask],
process: Process.Sequential,
verbose: true
});
const result = await crew.kickoff();
return result;
}
```
### Step 3 - Run!
```python Python theme={null}
result = crew_with_mcp_server(
mcp_server_url=response.strata_server_url,
user_query="Check my latest 5 emails and summarize them in a Slack message to #general"
)
print(f"\nFinal Response: {result}")
```
```typescript TypeScript theme={null}
result = await crewWithMcpServer(
response.strataServerUrl,
"Check my latest emails and summarize them in a Slack message to #updates"
);
console.log(`\nFinal Response: ${result}`);
```
Perfect! You've integrated Crew with Strata MCP servers.
## Security Best Practices
When using CrewAI with Klavis MCP servers, follow these security guidelines:
```python Python theme={null}
def create_secure_crew():
"""Demonstrates secure MCP server integration with CrewAI"""
# 1. Use environment variables for sensitive data
api_key = os.getenv("KLAVIS_API_KEY")
if not api_key:
raise ValueError("KLAVIS_API_KEY environment variable is required")
# 2. Validate server URLs (use HTTPS in production)
server_params = [{
"url": server_instance.server_url,
"transport": "streamable-http"
}]
# 3. Always use context managers for proper resource cleanup
try:
with MCPServerAdapter(server_params) as mcp_tools:
# 4. Validate available tools before use
if not mcp_tools:
raise ValueError("No tools available from MCP server")
print(f"ā Securely connected with {len(mcp_tools)} tools")
# 5. Create agents with limited scope
agent = Agent(
role="Data Analyst",
goal="Analyze data within defined parameters",
backstory="You operate within strict security guidelines.",
tools=mcp_tools,
reasoning=False, # Disable for production
verbose=False # Disable verbose logging in production
)
return agent
except Exception as e:
print(f"š Security check failed: {e}")
return None
# Example usage
secure_agent = create_secure_crew()
if secure_agent:
print("ā Secure crew created successfully")
```
```typescript TypeScript theme={null}
function createSecureCrew() {
// 1. Use environment variables for sensitive data
const apiKey = process.env.KLAVIS_API_KEY;
if (!apiKey) {
throw new Error("KLAVIS_API_KEY environment variable is required");
}
// 2. Validate server URLs (use HTTPS in production)
const serverParams = [{
url: serverInstance.serverUrl,
transport: "streamable-http"
}];
// 3. Always handle errors properly
try {
// 4. Validate available tools before use
const mcpTools = new MCPServerAdapter(serverParams);
if (!mcpTools) {
throw new Error("No tools available from MCP server");
}
console.log(`ā Securely connected with tools`);
// 5. Create agents with limited scope
const agent = new Agent({
role: "Data Analyst",
goal: "Analyze data within defined parameters",
backstory: "You operate within strict security guidelines.",
tools: mcpTools,
reasoning: false, // Disable for production
verbose: false // Disable verbose logging in production
});
return agent;
} catch (error) {
console.error(`š Security check failed: ${error}`);
return null;
}
}
// Example usage
const secureAgent = createSecureCrew();
if (secureAgent) {
console.log("ā Secure crew created successfully");
}
```
## Available MCP Servers
CrewAI works with all Klavis MCP servers. Here are some popular options:
Gmail, Slack, Discord, Outlook
YouTube, Notion, Google Docs, WordPress
GitHub, Jira, Linear, Confluence
Google Sheets, Supabase, PostgreSQL
Salesforce, HubSpot, Asana, ClickUp
Google Drive, Dropbox, OneDrive
## Summary
CrewAI + Klavis integration enables you to build sophisticated multi-agent AI systems with real-world capabilities. Key benefits include:
### š **CrewAI + Klavis Benefits:**
* **Seamless Integration**: MCPServerAdapter makes MCP connection effortless
* **Agent Specialization**: Each agent can focus on specific domains
* **Scalable Architecture**: Easy to add more agents and MCP servers
* **Professional AI Teams**: Create sophisticated multi-agent systems
* **Real-World Impact**: Connect AI to actual business tools and services
**Ready to build your first AI crew?** Start with a simple agent and expand from there! šš„
# Fireworks AI
Source: https://www.klavis.ai/docs/ai-platform-integration/fireworks-ai
Learn how to build AI agents that integrate Fireworks AI's LLMs with Klavis MCP Servers
## Prerequisites
Before we begin, you'll need:
Get your API key from Fireworks AI
Get your API key from Klavis AI
## Installation
First, install the required packages:
```bash Python theme={null}
pip install fireworks-ai klavis
```
```bash TypeScript theme={null}
npm install fireworks-ai klavis
```
## Setup Environment Variables
```python Python theme={null}
import os
# Set environment variables
os.environ["FIREWORKS_API_KEY"] = "your-fireworks-api-key-here" # Replace with your actual Fireworks API key
os.environ["KLAVIS_API_KEY"] = "your-klavis-api-key-here" # Replace with your actual Klavis API key
```
```typescript TypeScript theme={null}
// Set environment variables in your .env file
process.env.FIREWORKS_API_KEY = "your-fireworks-api-key-here"; // Replace with your actual Fireworks API key
process.env.KLAVIS_API_KEY = "your-klavis-api-key-here"; // Replace with your actual Klavis API key
```
## Basic Setup
```python Python theme={null}
import os
import json
from fireworks.client import Fireworks
from klavis import Klavis
from klavis.types import McpServerName, ToolFormat
# Initialize clients
fireworks_client = Fireworks(api_key=os.getenv("FIREWORKS_API_KEY"))
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
```
```typescript TypeScript theme={null}
import Fireworks from 'fireworks-ai';
import { KlavisClient, Klavis } from 'klavis';
// Initialize clients
const fireworksClient = new Fireworks({ apiKey: process.env.FIREWORKS_API_KEY });
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });
```
## AI Agent with MCP Integration
Now we'll create an intelligent agent that can use MCP servers through Klavis API. This agent will:
1. **Discover Tools**: Automatically find available tools from MCP servers
2. **Function Calling**: Use Fireworks AI's function calling capabilities
3. **Tool Execution**: Execute tools through Klavis API
4. **Smart Responses**: Generate intelligent responses based on tool results
```python Python theme={null}
class Agent:
def __init__(self, fireworks_client, klavis_client, mcp_server_url):
self.fireworks = fireworks_client
self.klavis = klavis_client
self.mcp_server_url = mcp_server_url
self.model = "accounts/fireworks/models/qwen2p5-72b-instruct"
print(f"š¤ Agent initialized with model: {self.model}")
def process_request(self, user_message):
# 1. Get available tools
mcp_tools = self.klavis.mcp_server.list_tools(
server_url=self.mcp_server_url,
format=ToolFormat.OPENAI
)
# 2. Call LLM with tools
messages = [
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": user_message}
]
response = self.fireworks.chat.completions.create(
model=self.model,
messages=messages,
tools=mcp_tools.tools
)
assistant_message = response.choices[0].message
messages.append(assistant_message)
# 3. If LLM wants to use tools
if assistant_message.tool_calls:
# Execute each tool call
for tool_call in assistant_message.tool_calls:
tool_name = tool_call.function.name
tool_args = json.loads(tool_call.function.arguments)
print(f"š ļø Calling tool: {tool_name} with args: {tool_args}")
# Call tool via Klavis SDK
tool_result = self.klavis.mcp_server.call_tools(
server_url=self.mcp_server_url,
tool_name=tool_name,
tool_args=tool_args
)
messages.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": str(tool_result)
})
# 4. Get final response from LLM
final_response = self.fireworks.chat.completions.create(
model=self.model,
messages=messages
)
return final_response.choices[0].message.content
# If no tools needed, return the assistant message directly
return assistant_message.content
```
```typescript TypeScript theme={null}
class Agent {
private fireworks: Fireworks;
private klavis: KlavisClient;
private mcpServerUrl: string;
private model: string;
constructor(fireworksClient: Fireworks, klavisClient: KlavisClient, mcpServerUrl: string) {
this.fireworks = fireworksClient;
this.klavis = klavisClient;
this.mcpServerUrl = mcpServerUrl;
this.model = "accounts/fireworks/models/qwen2p5-72b-instruct";
console.log(`š¤ Agent initialized with model: ${this.model}`);
}
async processRequest(userMessage: string) {
// 1. Get available tools
const mcpTools = await this.klavis.mcpServer.listTools({
serverUrl: this.mcpServerUrl,
format: Klavis.ToolFormat.Openai
});
// 2. Call LLM with tools
const messages = [
{ role: "system", content: "You are a helpful assistant." },
{ role: "user", content: userMessage }
];
const response = await this.fireworks.chat.completions.create({
model: this.model,
messages: messages,
tools: mcpTools.tools
});
const assistantMessage = response.choices[0].message;
messages.push(assistantMessage);
// 3. If LLM wants to use tools
if (assistantMessage.tool_calls) {
// Execute each tool call
for (const toolCall of assistantMessage.tool_calls) {
const toolName = toolCall.function.name;
const toolArgs = JSON.parse(toolCall.function.arguments);
console.log(`š ļø Calling tool: ${toolName} with args:`, toolArgs);
// Call tool via Klavis SDK
const toolResult = await this.klavis.mcpServer.callTools({
serverUrl: this.mcpServerUrl,
toolName: toolName,
toolArgs: toolArgs
});
messages.push({
role: "tool",
tool_call_id: toolCall.id,
content: JSON.stringify(toolResult)
});
}
// 4. Get final response from LLM
const finalResponse = await this.fireworks.chat.completions.create({
model: this.model,
messages: messages
});
return finalResponse.choices[0].message.content;
}
// If no tools needed, return the assistant message directly
return assistantMessage.content;
}
}
```
## Use Case Examples
### Example 1: Summarize YouTube Video
Set up Fireworks AI and Klavis API clients
Create a YouTube MCP server instance
Use the agent to analyze and summarize a YouTube video
```python Python theme={null}
YOUTUBE_VIDEO_URL = "https://www.youtube.com/watch?v=kPXvf2-C_Hs" # Pick a video you like!
# 1. Create YouTube MCP server instance
youtube_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.YOUTUBE,
user_id="1234"
)
# 2. Create an agent with YouTube MCP server
agent = Agent(fireworks_client, klavis_client, youtube_mcp_instance.server_url)
# 3. Process the request
response = agent.process_request(
f"Summarize this YouTube video with timestamps: {YOUTUBE_VIDEO_URL}"
)
print(response)
```
```typescript TypeScript theme={null}
const YOUTUBE_VIDEO_URL = "https://www.youtube.com/watch?v=kPXvf2-C_Hs"; // Pick a video you like!
// 1. Create YouTube MCP server instance
const youtubeMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Youtube,
userId: "1234"
});
// 2. Create an agent with YouTube MCP server
const agent = new Agent(fireworksClient, klavisClient, youtubeMcpInstance.serverUrl);
// 3. Process the request
const response = await agent.processRequest(
`Summarize this YouTube video with timestamps: ${YOUTUBE_VIDEO_URL}`
);
console.log(response);
```
### Example 2: Send Email via Gmail
Gmail integration requires OAuth authentication, so you'll need to authorize the application in your browser.
Create a Gmail MCP server instance
Complete OAuth flow for Gmail access
Use the agent to send an email
```python Python theme={null}
import webbrowser
# Create Gmail MCP server instance
gmail_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.GMAIL,
user_id="1234"
)
# Redirect to Gmail OAuth page
webbrowser.open(gmail_mcp_instance.oauth_url)
print(f"š Opening OAuth authorization for Gmail, if you are not redirected, please open the following URL in your browser: {gmail_mcp_instance.oauth_url}")
EMAIL_SUBJECT = "Hello, World!"
EMAIL_BODY = "This is a test email sent using Fireworks AI and Klavis integration."
EMAIL_RECIPIENT = "recipient@example.com" # Replace with your email
# After OAuth authorization, create an agent with Gmail MCP server
agent = Agent(fireworks_client, klavis_client, gmail_mcp_instance.server_url)
# Send the email
response = agent.process_request(
f"Send an email to {EMAIL_RECIPIENT} with subject {EMAIL_SUBJECT} and body {EMAIL_BODY}"
)
print(response)
```
```typescript TypeScript theme={null}
// Create Gmail MCP server instance
const gmailMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Gmail,
userId: "1234"
});
// Redirect to Gmail OAuth page
console.log("š Opening OAuth authorization for Gmail");
console.log(`If you are not redirected, please open the following URL in your browser: ${gmailMcpInstance.oauthUrl}`);
// In a web environment, you might redirect the user
window.open(gmailMcpInstance.oauthUrl);
const EMAIL_SUBJECT = "Hello, World!";
const EMAIL_BODY = "This is a test email sent using Fireworks AI and Klavis integration.";
const EMAIL_RECIPIENT = "recipient@example.com"; // Replace with your email
// After OAuth authorization, create an agent with Gmail MCP server
const agent = new Agent(fireworksClient, klavisClient, gmailMcpInstance.serverUrl);
// Send the email
const response = await agent.processRequest(
`Send an email to ${EMAIL_RECIPIENT} with subject ${EMAIL_SUBJECT} and body ${EMAIL_BODY}`
);
console.log(response);
```
## Next Steps
Try other available servers like Slack, Notion, CRM, etc.
Experiment with various models like Llama, Mixtral, or Deepseek for different use cases
Create sophisticated agents that combine Gmail + Slack + Notion for complete business automation
Scale these patterns for production applications
## Useful Resources
* [Fireworks AI Documentation](https://docs.fireworks.ai/)
* [Klavis AI Documentation](https://www.klavis.ai/docs/)
* [MCP Protocol Specification](https://modelcontextprotocol.io/)
* [Klavis MCP Servers](/mcp-server)
**Happy building with Fireworks AI and Klavis!** š
# Gemini
Source: https://www.klavis.ai/docs/ai-platform-integration/gemini
Learn how to build AI agents that integrate Google's Gemini with Strata MCP servers to build AI agents that can interact with Gmail and Slack.
[](https://colab.research.google.com/github/klavis-ai/klavis/blob/main/examples/google-genai/Use_Klavis_with_Gemini.ipynb)
# Gemini + Klavis AI Integration
This tutorial demonstrates how to use Google's Gemini with function calling with Klavis MCP (Model Context Protocol) servers.
## Prerequisites
Before we begin, you'll need:
Get your API key from Google AI Studio
Get your API key from Klavis AI
## Installation
First, install the required packages:
```bash Python theme={null}
pip install google-genai klavis
```
```bash TypeScript theme={null}
npm install @google/genai klavis
```
## Full Code Examples
For complete working examples, check out the source code:
## Setup Environment Variables
```python Python theme={null}
import os
# Set environment variables
os.environ["GEMINI_API_KEY"] = "YOUR_GEMINI_API_KEY" # Replace with your actual Gemini API key
os.environ["KLAVIS_API_KEY"] = "YOUR_KLAVIS_API_KEY" # Replace with your actual Klavis API key
```
```typescript TypeScript theme={null}
import { GoogleGenAI } from '@google/genai';
import { KlavisClient, Klavis } from 'klavis';
// Set environment variables
process.env.GEMINI_API_KEY = "YOUR_GEMINI_API_KEY"; // Replace with your actual Gemini API key
process.env.KLAVIS_API_KEY = "YOUR_KLAVIS_API_KEY"; // Replace with your actual Klavis API key
```
### Step 1 - Create Strata MCP Server with Gmail and Slack
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName, ToolFormat
import webbrowser
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GMAIL, McpServerName.SLACK],
user_id="1234"
)
# Handle OAuth authorization for each services
if response.oauth_urls:
for server_name, oauth_url in response.oauth_urls.items():
webbrowser.open(oauth_url)
print(f"Or please open this URL to complete {server_name} OAuth authorization: {oauth_url}")
```
```typescript TypeScript theme={null}
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });
const response = await klavisClient.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Gmail, Klavis.McpServerName.Slack],
userId: "1234"
});
// Handle OAuth authorization for each services
if (response.oauthUrls) {
for (const [serverName, oauthUrl] of Object.entries(response.oauthUrls)) {
window.open(oauthUrl);
// Wait for user to complete OAuth
await new Promise(resolve => {
const input = prompt(`Press OK after completing ${serverName} OAuth authorization...`);
resolve(input);
});
}
}
```
**OAuth Authorization Required**: The code above will open browser windows for each service. Click through the OAuth flow to authorize access to your accounts.
### Step 2 - Create method to use MCP Server with Claude
This method handles multiple rounds of tool calls until a final response is ready, allowing the AI to chain tool executions for complex tasks.
```python Python theme={null}
import json
from google import genai
from google.genai import types
def gemini_with_mcp_server(mcp_server_url: str, user_query: str):
gemini_client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
contents = []
contents.append(types.Content(role="user", parts=[types.Part(text=user_query)]))
mcp_server_tools = klavis_client.mcp_server.list_tools(
server_url=mcp_server_url,
format=ToolFormat.GEMINI
)
max_iterations = 10
iteration = 0
while iteration < max_iterations:
iteration += 1
response = gemini_client.models.generate_content(
model='gemini-2.5-flash',
contents=contents,
config=types.GenerateContentConfig(tools=mcp_server_tools.tools)
)
if response.candidates and response.candidates[0].content.parts:
contents.append(response.candidates[0].content)
# Check if there are function calls to execute
has_function_calls = False
for part in response.candidates[0].content.parts:
if hasattr(part, 'function_call') and part.function_call:
has_function_calls = True
function_name = part.function_call.name
function_args = dict(part.function_call.args)
print(f"Calling: {function_name}, with args: {function_args}")
result = klavis_client.mcp_server.call_tools(
server_url=mcp_server_url,
tool_name=function_name,
tool_args=function_args
)
function_response_part = types.Part.from_function_response(
name=function_name,
response={'result': result.result}
)
function_response_content = types.Content(
role='tool',
parts=[function_response_part]
)
contents.append(function_response_content)
if has_function_calls:
continue
else:
return response.text
else:
return "No response generated."
return "Max iterations reached without final response"
```
```typescript TypeScript theme={null}
async function geminiWithMcpServer(mcpServerUrl: string, userQuery: string) {
const geminiClient = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const contents = [];
contents.push({ role: "user", parts: [{ text: userQuery }] });
const mcpServerTools = await klavisClient.mcpServer.listTools({
serverUrl: mcpServerUrl,
format: Klavis.ToolFormat.Gemini
});
const maxIterations = 10;
let iteration = 0;
while (iteration < maxIterations) {
iteration++;
const response = await geminiClient.models.generateContent({
model: 'gemini-2.5-flash',
contents: contents,
config: { tools: mcpServerTools.tools }
});
if (response.candidates && response.candidates[0].content.parts) {
contents.push(response.candidates[0].content);
// Check if there are function calls to execute
let hasFunctionCalls = false;
for (const part of response.candidates[0].content.parts) {
if (part.functionCall) {
hasFunctionCalls = true;
const functionName = part.functionCall.name;
const functionArgs = part.functionCall.args;
console.log(`š§ Calling: ${functionName}, with args:`, functionArgs);
const result = await klavisClient.mcpServer.callTools({
serverUrl: mcpServerUrl,
toolName: functionName,
toolArgs: functionArgs
});
const functionResponsePart = {
functionResponse: {
name: functionName,
response: { result: result.result }
}
};
const functionResponseContent = {
role: 'tool',
parts: [functionResponsePart]
};
contents.push(functionResponseContent);
}
}
if (hasFunctionCalls) {
continue;
} else {
return response.text;
}
} else {
return "No response generated.";
}
}
return "Max iterations reached without final response";
}
```
### Step 3 - Run!
```python Python theme={null}
result = gemini_with_mcp_server(
mcp_server_url=response.strata_server_url,
user_query="Check my latest 5 gmails and summarize them in a Slack message to #engineering"
)
print(f"\nš¤ Final Response: {result}")
```
```typescript TypeScript theme={null}
const result = await geminiWithMcpServer(
response.strataServerUrl,
"Check my latest 5 gmails and summarize them in a Slack message to #engineering"
);
console.log(`\nš¤ Final Response: ${result}`);
```
Perfect! You've integrated Gemini with Klavis MCP servers.
## Next Steps
Try other available servers like Slack, Notion, GitHub, etc.
Build workflows that combine text, images, and other media
Scale these patterns for production applications
Build custom MCP servers for your specific needs
## Useful Resources
* [Google AI Documentation](https://ai.google.dev/)
* [Gemini API Reference](https://ai.google.dev/api)
* [Klavis AI Documentation](https://www.klavis.ai/docs/)
* [MCP Protocol Specification](https://modelcontextprotocol.io/)
* [Klavis MCP Servers](/mcp-server)
**Happy building!** š
# Google ADK
Source: https://www.klavis.ai/docs/ai-platform-integration/google-adk
This tutorial demonstrates how to integrate Google Agent Development Kit (ADK) with Klavis MCP servers to build AI agents that can interact with Gmail and Slack.
You can find the complete example code in Klavis GitHub repository **[here ->](https://github.com/Klavis-AI/klavis/tree/main/examples/google_adk/python)**
## Prerequisites
Before we begin, you'll need: [Google API key](https://console.cloud.google.com/apis/credentials) and [Klavis API key](https://www.klavis.ai/home/api-keys).
## Installation
First, install the required packages:
```bash theme={null}
pip install google-adk klavis
```
## Setup Environment Variables
```python theme={null}
import os
from dotenv import load_dotenv
load_dotenv()
os.environ["KLAVIS_API_KEY"] = "YOUR_KLAVIS_API_KEY" # Replace
```
### Step 1 - Create an Agent Project
Run the ADK create command to start a new agent project:
```bash theme={null}
adk create my_agent
```
This will create the following project structure:
```
my_agent/
agent.py # main agent code
.env # API keys or project IDs
__init__.py
```
### Step 2 - Configure Agent with Klavis MCP
The `agent.py` file contains a `root_agent` definition which is the only required element of an ADK agent.
Update your `agent.py` to integrate Klavis MCP servers:
```python theme={null}
import os
import webbrowser
from google.adk.agents.llm_agent import Agent
from google.adk.tools.mcp_tool import StreamableHTTPConnectionParams
from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
from klavis import Klavis
from klavis.types import McpServerName
from dotenv import load_dotenv
load_dotenv()
KLAVIS_API_KEY = os.getenv("KLAVIS_API_KEY")
# Initialize Klavis and set up Strata server
klavis_client = Klavis(api_key=KLAVIS_API_KEY)
user_id = "user_123"
# Create Strata server with multiple MCP servers
strata_response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GMAIL, McpServerName.SLACK],
user_id=user_id
)
# Handle OAuth authentication
if strata_response.oauth_urls:
for server_name, oauth_url in strata_response.oauth_urls.items():
user_integration_auth = klavis_client.user.get_user_auth(
user_id=user_id,
server_name=server_name
)
if not user_integration_auth.is_authenticated:
print(f"š Opening OAuth for {server_name}...")
webbrowser.open(oauth_url)
input(f"Press Enter after completing {server_name} OAuth authorization...")
mcp_server_url = strata_response.strata_server_url
# Create AI agent with MCP toolset (exposed at module level for ADK)
root_agent = Agent(
name="my_agent",
model="gemini-2.5-flash",
description="An agent with access to tools through Klavis MCP",
instruction="You are a helpful assistant with access to MCP tools.",
tools=[
McpToolset(
connection_params=StreamableHTTPConnectionParams(
url=mcp_server_url,
),
)
],
)
```
**OAuth Authorization Required**: The code above will open browser windows for each service. Click through the OAuth flow to authorize access to your accounts.
### Step 3 - Run Your Agent
Launch the web interface to interact with your agent:
```bash theme={null}
adk web
```
This will start a local web server where you can chat with your agent and watch it use the Gmail and Slack MCP tools.
Perfect! You've integrated Google ADK with Klavis MCP servers.
## Next Steps
Explore available MCP servers
REST endpoints and schemas
## Useful Resources
* [Google ADK Documentation](https://google.github.io/adk/)
* [Google ADK GitHub](https://github.com/google/adk)
* [MCP Protocol Specification](https://modelcontextprotocol.io/)
**Happy building!** š
# LangChain
Source: https://www.klavis.ai/docs/ai-platform-integration/langchain
This tutorial demonstrates how to integrate LangChain's agent framework with Strata MCP servers to build AI agents that can interact with Gmail and Slack.
## Prerequisites
Before we begin, you'll need [OpenAI API key](\(https://platform.openai.com/api-keys\)) and [Klavis API key](https://www.klavis.ai/home/api-keys).
## Installation
First, install the required packages:
```bash Python theme={null}
pip install langchain-mcp-adapters langgraph langchain-openai klavis
```
```bash TypeScript theme={null}
npm install @langchain/mcp-adapters @langchain/langgraph @langchain/openai klavis
```
## Setup Environment Variables
```python Python theme={null}
import os
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY" # Replace
os.environ["KLAVIS_API_KEY"] = "YOUR_KLAVIS_API_KEY" # Replace
```
```typescript TypeScript theme={null}
// Set environment variables
process.env.OPENAI_API_KEY = "YOUR_OPENAI_API_KEY"; // Replace with your actual OpenAI API key
process.env.KLAVIS_API_KEY = "YOUR_KLAVIS_API_KEY"; // Replace with your actual Klavis API key
```
### Step 1 - Create Strata MCP Server with Gmail and Slack
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName, ToolFormat
import webbrowser
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GMAIL, McpServerName.SLACK],
user_id="1234"
)
# Handle OAuth authorization for each services
if response.oauth_urls:
for server_name, oauth_url in response.oauth_urls.items():
webbrowser.open(oauth_url)
print(f"Or please open this URL to complete {server_name} OAuth authorization: {oauth_url}")
```
```typescript TypeScript theme={null}
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });
const response = await klavisClient.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Gmail, Klavis.McpServerName.Slack],
userId: "1234"
});
// Handle OAuth authorization for each services
if (response.oauthUrls) {
for (const [serverName, oauthUrl] of Object.entries(response.oauthUrls)) {
window.open(oauthUrl);
// Wait for user to complete OAuth
await new Promise(resolve => {
const input = prompt(`Press OK after completing ${serverName} OAuth authorization...`);
resolve(input);
});
}
}
```
*OAuth Authorization Required*: The code above will open browser windows for each service. Click through the OAuth flow to authorize access to your accounts.
### Step 2 - Create LangChain Agent with Strata MCP Server
```python Python theme={null}
import asyncio
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
# Initialize LLM
llm = ChatOpenAI(model="gpt-4o-mini", api_key=os.getenv("OPENAI_API_KEY"))
# Create MCP client with Strata server
mcp_client = MultiServerMCPClient({
"strata": {
"transport": "streamable_http",
"url": response.strata_server_url
}
})
# Get tools from Strata MCP server
tools = asyncio.run(mcp_client.get_tools())
# Create agent with MCP-based tools
agent = create_react_agent(
model=llm,
tools=tools,
prompt="You are a helpful assistant that uses MCP tools to interact with Gmail and Slack."
)
print("š¤ LangChain agent created successfully!")
```
```typescript TypeScript theme={null}
// Initialize LLM
const llm = new ChatOpenAI({
modelName: "gpt-4o-mini",
apiKey: process.env.OPENAI_API_KEY
});
// Create MCP client with Strata server
const mcpClient = new MultiServerMCPClient({
throwOnLoadError: true,
useStandardContentBlocks: true,
mcpServers: {
strata: {
url: response.strataServerUrl,
transport: "streamable_http"
}
}
});
// Get tools from Strata MCP server
const tools = await mcpClient.getTools();
// Create agent with MCP-based tools
const agent = createReactAgent({
llm: llm,
tools: tools,
systemMessage: "You are a helpful assistant that uses MCP tools to interact with Gmail and Slack."
});
console.log("š¤ LangChain agent created successfully!");
```
### Step 3 - Run!
```python Python theme={null}
response_message = asyncio.run(agent.ainvoke({
"messages": [{"role": "user", "content": "Check my latest 5 emails and summarize them in a Slack message to #general"}]
}))
print(f"\nš¤ Final Response: {response_message['messages'][-1].content}")
```
```typescript TypeScript theme={null}
try {
const response = await agent.invoke({
messages: [{ role: "user", content: "Check my latest emails and summarize them in a Slack message to #updates" }]
});
console.log(`\nš¤ Final Response:`, response);
} catch (error) {
console.error("Error during agent execution:", error);
} finally {
await mcpClient.close();
}
```
Perfect! You've integrated LangChain with Klavis MCP servers.
## Next Steps
Explore available MCP servers
REST endpoints and schemas
## Useful Resources
* [LangChain Documentation](https://python.langchain.com/docs/)
* [LangGraph Documentation](https://langchain-ai.github.io/langgraph/)
* [LangChain MCP Adapters](https://pypi.org/project/langchain-mcp-adapters/)
* [MCP Protocol Specification](https://modelcontextprotocol.io/)
*Happy building* š
# LlamaIndex
Source: https://www.klavis.ai/docs/ai-platform-integration/llamaindex
Learn how to build AI agents that integrate with Strata MCP servers to build AI agents that can interact with Gmail and Slack.
## Partnership
LlamaIndex has officially showcased their integration with Klavis AI in [this LinkedIn post](https://www.linkedin.com/posts/llamaindex_build-ai-agents-that-connect-to-youtube-activity-7344107221221355521-UrOl?utm_source=share\&utm_medium=member_desktop\&rcm=ACoAACh0ewEBh9MR1nb_U_x3e5bqgDYgETJ8d5Y), demonstrating how to build AI agents that connect to MCP Servers in just a few lines of code.
## Prerequisites
Before we begin, you'll need:
Get your API key from OpenAI Platform (LlamaIndex uses OpenAI as the default LLM)
Get your API key from Klavis AI
## Installation
First, install the required packages:
```bash Python theme={null}
pip install llama-index llama-index-tools-mcp klavis
```
```bash TypeScript theme={null}
npm install @llamaindex/tools @llamaindex/workflow @llamaindex/openai klavis
```
## Setup Environment Variables
```python Python theme={null}
import os
# Set environment variables
os.environ["OPENAI_API_KEY"] = "your-openai-api-key-here" # Replace with your actual OpenAI API key
os.environ["KLAVIS_API_KEY"] = "your-klavis-api-key-here" # Replace with your actual Klavis API key
```
```typescript TypeScript theme={null}
// Set environment variables in your .env file
process.env.OPENAI_API_KEY = "your-openai-api-key-here"; // Replace with your actual OpenAI API key
process.env.KLAVIS_API_KEY = "your-klavis-api-key-here"; // Replace with your actual Klavis API key
```
## Basic Setup
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
from llama_index.llms.openai import OpenAI
from llama_index.tools.mcp import (
BasicMCPClient,
get_tools_from_mcp_url,
aget_tools_from_mcp_url
)
# Initialize clients
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
llm = OpenAI(model="gpt-4o-mini", api_key=os.getenv("OPENAI_API_KEY"))
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
import { mcp } from "@llamaindex/tools";
import { agent, multiAgent } from "@llamaindex/workflow";
import { openai } from "@llamaindex/openai";
// Initialize clients
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });
```
### Step 1 - Create Strata MCP Server with Gmail and Slack
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName, ToolFormat
import webbrowser
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GMAIL, McpServerName.SLACK],
user_id="1234"
)
# Handle OAuth authorization for each services
if response.oauth_urls:
for server_name, oauth_url in response.oauth_urls.items():
webbrowser.open(oauth_url)
print(f"Or please open this URL to complete {server_name} OAuth authorization: {oauth_url}")
```
```typescript TypeScript theme={null}
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });
const response = await klavisClient.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Gmail, Klavis.McpServerName.Slack],
userId: "1234"
});
// Handle OAuth authorization for each services
if (response.oauthUrls) {
for (const [serverName, oauthUrl] of Object.entries(response.oauthUrls)) {
window.open(oauthUrl);
// Wait for user to complete OAuth
await new Promise(resolve => {
const input = prompt(`Press OK after completing ${serverName} OAuth authorization...`);
resolve(input);
});
}
}
```
**OAuth Authorization Required**: The code above will open browser windows for each service. Click through the OAuth flow to authorize access to your accounts.
### Step 2 - Create method to use MCP Server with LlamaIndex
This method handles multiple rounds of tool calls until a final response is ready, allowing the AI to chain tool executions for complex tasks.
```python Python theme={null}
import json
from llama_index.core.agent.workflow import FunctionAgent, AgentWorkflow
async def llamaindex_with_mcp_server(mcp_server_url: str, user_query: str):
llm = OpenAI(model="gpt-4o-mini", api_key=os.getenv("OPENAI_API_KEY"))
all_tools = await aget_tools_from_mcp_url(
mcp_server_url,
client=BasicMCPClient(mcp_server_url)
)
communication_agent = FunctionAgent(
name="communication_agent",
description="Agent that can read emails from Gmail and send messages to Slack",
tools=all_tools,
llm=llm,
system_prompt="You are a helpful assistant. Use the available tools to answer the user's question.",
max_iterations=10
)
workflow = AgentWorkflow(
agents=[communication_agent],
root_agent="communication_agent"
)
resp = await workflow.run(user_msg=user_query)
return resp.response.content
```
```typescript TypeScript theme={null}
async function llamaindexWithMcpServer(mcpServerUrl: string, userQuery: string) {
const llm = new openai.OpenAI({
model: "gpt-4o-mini",
apiKey: process.env.OPENAI_API_KEY
});
const allTools = await mcp.getToolsFromMcpUrl(
mcpServerUrl,
new mcp.BasicMCPClient(mcpServerUrl)
);
const communicationAgent = new agent.FunctionAgent({
name: "communication_agent",
description: "Agent that can read emails from Gmail and send messages to Slack",
tools: allTools,
llm: llm,
systemPrompt: "You are a helpful assistant. Use the available tools to answer the user's question.",
maxIterations: 10
});
const workflow = new agent.AgentWorkflow({
agents: [communicationAgent],
rootAgent: "communication_agent"
});
const resp = await workflow.run({ userMsg: userQuery });
return resp.response.content;
}
```
### Step 3 - Run!
```python Python theme={null}
result = await llamaindex_with_mcp_server(
mcp_server_url=response.strata_server_url,
user_query="Check my latest 5 emails and summarize them in a Slack message to #general"
)
print(f"\nFinal Response: {result}")
```
```typescript TypeScript theme={null}
result = await llamaindexWithMcpServer(
response.strataServerUrl,
"Check my latest 5 emails and summarize them in a Slack message to #general"
);
console.log(`\nFinal Response: ${result}`);
```
Perfect! You've integrated LLamaIndex with Strata MCP servers.
## Next Steps
Explore available MCP servers
REST endpoints and schemas
## Useful Resources
* [LlamaIndex Documentation](https://docs.llamaindex.ai/)
* [Klavis AI Documentation](https://www.klavis.ai/docs/)
* [MCP Protocol Specification](https://modelcontextprotocol.io/)
* [Klavis MCP Servers](/mcp-server)
**Happy building with LlamaIndex and Klavis!** š
# Mastra
Source: https://www.klavis.ai/docs/ai-platform-integration/mastra
Learn how to build AI agents that integrate Mastra framework with Klavis MCP Servers for enhanced functionality
## Partnership
Mastra has officially featured Klavis AI in [their MCP registry documentation](https://mastra.ai/en/docs/tools-mcp/mcp-overview#connecting-to-an-mcp-registry), showcasing how to connect to MCP servers for building powerful AI agents.
## Prerequisites
Before we begin, you'll need [OpenAI API key](https://platform.openai.com/api-keys) and [Klavis API key](https://www.klavis.ai/home/api-keys).
You can find the complete example code in Klavis GitHub repository: **[š Checkout here](https://github.com/Klavis-AI/klavis/tree/main/examples/mastra-klavis)**
## Setup Environment Variables
Create a `.env` file in your project root:
```env theme={null}
OPENAI_API_KEY=your_openai_api_key_here
KLAVIS_API_KEY=your_klavis_api_key_here
```
## Project Structure
```
mastra-klavis-example/
āāā src/
ā āāā mastra/
ā āāā index.ts
āāā package.json
āāā tsconfig.json
```
## Code Example
```typescript theme={null}
import { Mastra } from '@mastra/core/mastra';
import { Agent } from '@mastra/core/agent';
import { openai } from '@ai-sdk/openai';
import { MCPClient } from '@mastra/mcp';
import { KlavisClient, Klavis } from 'klavis';
import open from 'open';
// Creates an MCP Agent with tools from Klavis Strata server
export const createMcpAgent = async (userId: string = 'test-user'): Promise => {
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP Server with Gmail and Slack
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Gmail, Klavis.McpServerName.Slack],
userId
});
// Handle OAuth authorization for each service
if (response.oauthUrls) {
for (const [serverName, oauthUrl] of Object.entries(response.oauthUrls)) {
await open(oauthUrl);
console.log(`Please complete ${serverName} OAuth authorization at: ${oauthUrl}`);
}
}
// Initialize the MCP client with Strata server URL
const mcpClient = new MCPClient({
servers: {
strata: {
url: new URL(response.strataServerUrl)
}
}
});
// Create agent
return new Agent({
name: 'MCP Agent',
instructions: `You are an AI agent with access to MCP tools.`,
model: openai('gpt-4o-mini'),
tools: await mcpClient.getTools()
});
};
const agent = await createMcpAgent();
export const mastra = new Mastra({
agents: { agent }
});
```
## Running the Agent
```bash theme={null}
npm install
npm run dev
```
## Video Tutorial
## Summary
This implementation demonstrates how to integrate Mastra with Klavis Strata servers to access multiple MCP services (Gmail and Slack) through a single unified server. The agent is configured with MCP tools and can interact with various services through the MCP protocol.
## Useful Resources
* [Mastra Doc](https://mastra.ai/docs)
* [Mastra GitHub Repo](https://github.com/mastra-ai/mastra)
* [MCP Spec](https://modelcontextprotocol.io/)
**Happy building with Mastra and Klavis!** š
# OpenAI
Source: https://www.klavis.ai/docs/ai-platform-integration/openai
This tutorial demonstrates how to integrate OpenAI's function calling capabilities with Strata MCP servers to build AI agents that can interact with Gmail and Slack.
## Prerequisites
Before we begin, you'll need [OpenAI API key](\(https://platform.openai.com/api-keys\)) and [Klavis API key](https://www.klavis.ai/home/api-keys).
## Installation
First, install the required packages:
```bash Python theme={null}
pip install openai klavis
```
```bash TypeScript theme={null}
npm install openai klavis
```
## Setup Environment Variables
```python Python theme={null}
import os
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY" # Replace
os.environ["KLAVIS_API_KEY"] = "YOUR_KLAVIS_API_KEY" # Replace
```
```typescript TypeScript theme={null}
import OpenAI from 'openai';
import { KlavisClient, Klavis } from 'klavis';
// Set environment variables
process.env.OPENAI_API_KEY = "YOUR_OPENAI_API_KEY"; // Replace with your actual OpenAI API key
process.env.KLAVIS_API_KEY = "YOUR_KLAVIS_API_KEY"; // Replace with your actual Klavis API key
```
### Step 1 - Create Strata MCP Server with Gmail and Slack
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName, ToolFormat
import webbrowser
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GMAIL, McpServerName.SLACK],
user_id="1234"
)
# Handle OAuth authorization for each services
if response.oauth_urls:
for server_name, oauth_url in response.oauth_urls.items():
webbrowser.open(oauth_url)
print(f"Or please open this URL to complete {server_name} OAuth authorization: {oauth_url}")
```
```typescript TypeScript theme={null}
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });
const response = await klavisClient.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Gmail, Klavis.McpServerName.Slack],
userId: "1234"
});
// Handle OAuth authorization for each services
if (response.oauthUrls) {
for (const [serverName, oauthUrl] of Object.entries(response.oauthUrls)) {
window.open(oauthUrl);
// Wait for user to complete OAuth
await new Promise(resolve => {
const input = prompt(`Press OK after completing ${serverName} OAuth authorization...`);
resolve(input);
});
}
}
```
**OAuth Authorization Required**: The code above will open browser windows for each service. Click through the OAuth flow to authorize access to your accounts.
### Step 2 - Create method to use MCP Server with OpenAI
This method handles multiple rounds of tool calls until a final response is ready, allowing the AI to chain tool executions for complex tasks.
```python Python theme={null}
import json
from openai import OpenAI
def openai_with_mcp_server(mcp_server_url: str, user_query: str):
openai_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
messages = [
{"role": "system", "content": "You are a helpful assistant. Use the available tools to answer the user's question."},
{"role": "user", "content": f"{user_query}"}
]
tools_info = klavis_client.mcp_server.list_tools(
server_url=mcp_server_url,
format=ToolFormat.OPENAI
)
max_iterations = 10
iteration = 0
while iteration < max_iterations:
iteration += 1
response = openai_client.chat.completions.create(
model="gpt-4o-mini",
messages=messages,
tools=tools_info.tools,
tool_choice="auto",
)
assistant_message = response.choices[0].message
if assistant_message.tool_calls:
messages.append({
"role": "assistant",
"content": assistant_message.content,
"tool_calls": [
{
"id": tc.id,
"type": "function",
"function": {
"name": tc.function.name,
"arguments": tc.function.arguments
}
}
for tc in assistant_message.tool_calls
]
})
for tool_call in assistant_message.tool_calls:
tool_name = tool_call.function.name
tool_args = json.loads(tool_call.function.arguments)
print(f"Calling: {tool_name}")
print(f"Arguments: {json.dumps(tool_args, indent=2)}")
function_result = klavis_client.mcp_server.call_tools(
server_url=mcp_server_url,
tool_name=tool_name,
tool_args=tool_args
)
messages.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": str(function_result)
})
continue
else:
messages.append({"role": "assistant", "content": assistant_message.content})
return assistant_message.content
return "Max iterations reached without final response"
```
```typescript TypeScript theme={null}
async function openaiWithMcpServer(mcpServerUrl: string, userQuery: string) {
const openaiClient = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const messages = [
{ role: "system", content: "You are a helpful assistant. Use the available tools to answer the user's question." },
{ role: "user", content: userQuery }
];
const toolsInfo = await klavisClient.mcpServer.listTools({
serverUrl: mcpServerUrl,
format: Klavis.ToolFormat.Openai
});
const maxIterations = 10;
let iteration = 0;
while (iteration < maxIterations) {
iteration++;
const response = await openaiClient.chat.completions.create({
model: "gpt-4o-mini",
messages: messages,
tools: toolsInfo.tools,
tool_choice: "auto"
});
const assistantMessage = response.choices[0].message;
if (assistantMessage.tool_calls) {
messages.push({
role: "assistant",
content: assistantMessage.content,
tool_calls: assistantMessage.tool_calls.map(tc => ({
id: tc.id,
type: "function",
function: {
name: tc.function.name,
arguments: tc.function.arguments
}
}))
});
for (const toolCall of assistantMessage.tool_calls) {
const toolName = toolCall.function.name;
const toolArgs = JSON.parse(toolCall.function.arguments);
console.log(`š§ Calling: ${toolName}`);
console.log(` Arguments:`, JSON.stringify(toolArgs, null, 2));
const functionResult = await klavisClient.mcpServer.callTools({
serverUrl: mcpServerUrl,
toolName: toolName,
toolArgs: toolArgs
});
messages.push({
role: "tool",
tool_call_id: toolCall.id,
content: JSON.stringify(functionResult)
});
}
continue;
} else {
messages.push({ role: "assistant", content: assistantMessage.content });
return assistantMessage.content;
}
}
return "Max iterations reached without final response";
}
```
### Step 3 - Run!
```python Python theme={null}
result = openai_with_mcp_server(
mcp_server_url=response.strata_server_url,
user_query="Check my latest 5 emails and summarize them in a Slack message to #general"
)
print(f"\nš¤ Final Response: {result}")
```
```typescript TypeScript theme={null}
result = await openaiWithMcpServer(
response.strataServerUrl,
"Check my latest emails and summarize them in a Slack message to #updates"
);
console.log(`\nš¤ Final Response: ${result}`);
```
Perfect! You've integrated OpenAI with Klavis MCP servers.
## Next Steps
Explore available MCP servers
REST endpoints and schemas
## Useful Resources
* [OpenAI API Documentation](https://platform.openai.com/docs)
* [OpenAI Function Calling Guide](https://platform.openai.com/docs/guides/function-calling)
* [MCP Protocol Specification](https://modelcontextprotocol.io/)
**Happy building!** š
# Overview
Source: https://www.klavis.ai/docs/ai-platform-integration/overview
Integrate Klavis MCP Servers with leading AI platforms to build powerful AI agents
# AI Platform Integrations
Klavis AI seamlessly integrates with leading AI platforms, enabling you to build sophisticated AI agents that can interact with external services and APIs via MCP.
## Available Integrations
}
href="/ai-platform-integration/claude"
/>
{"CrewAI"}
}
href="/ai-platform-integration/crewai"
/>
{"Fireworks"}
}
href="/ai-platform-integration/fireworks-ai"
/>
{"Gemini"}
}
href="/ai-platform-integration/gemini"
/>
{"LangChain"}
}
href="/ai-platform-integration/langchain"
/>
{"LlamaIndex"}
}
href="/ai-platform-integration/llamaindex"
/>
}
href="/ai-platform-integration/mastra"
/>
{"OpenAI icon"}
}
href="/ai-platform-integration/openai"
/>
{"together.ai"}
}
href="/ai-platform-integration/together-ai"
/>
## How It Works
The integration pattern is consistent across all AI platforms:
1. **Setup**: Configure your AI platform API key and Klavis API key
2. **MCP Instance**: Create MCP server instances for the services you need (YouTube, Gmail, Slack, etc.)
3. **Agent Creation**: Build an AI agent that discovers available tools from MCP servers
4. **Function Calling**: The AI platform's LLM decides which tools to use based on user requests
5. **Tool Execution**: Tools are executed through Klavis API to remote MCP Servers and results are returned to the LLM
6. **Smart Response**: The LLM generates intelligent responses based on tool results
## Common Use Cases
Summarize YouTube videos, analyze documents, extract insights from web content
Send emails, post to Slack, create calendar events, manage contacts
Query databases, update spreadsheets, sync information across platforms
Create tickets in Jira, update Notion pages, manage Asana tasks
Web search, document analysis, code generation, API integrations
CRM updates, sales workflows, customer support, reporting
## Getting Started
Select the AI platform that best fits your needs from our available integrations
Obtain API keys from both your chosen AI platform and Klavis AI
Use our step-by-step integration guides to build your first AI agent
Add more MCP servers to give your agent access to additional tools and services
Ready to build intelligent AI agents? Choose your preferred AI platform and start building!
# Together AI
Source: https://www.klavis.ai/docs/ai-platform-integration/together-ai
Learn how to build AI agents that integrate Together AI's powerful LLMs with Klavis MCP Servers
## Prerequisites
Before we begin, you'll need:
Get your API key from Together AI
Get your API key from Klavis AI
## Installation
First, install the required packages:
```bash Python theme={null}
pip install together klavis
```
```bash TypeScript theme={null}
npm install together-ai klavis
```
## Setup Environment Variables
```python Python theme={null}
import os
# Set environment variables
os.environ["TOGETHER_API_KEY"] = "your-together-api-key-here" # Replace with your actual Together API key
os.environ["KLAVIS_API_KEY"] = "your-klavis-api-key-here" # Replace with your actual Klavis API key
```
```typescript TypeScript theme={null}
// Set environment variables in your .env file
process.env.TOGETHER_API_KEY = "your-together-api-key-here"; // Replace with your actual Together API key
process.env.KLAVIS_API_KEY = "your-klavis-api-key-here"; // Replace with your actual Klavis API key
```
## Basic Setup
```python Python theme={null}
import os
import json
from together import Together
from klavis import Klavis
from klavis.types import McpServerName, ToolFormat
# Initialize clients
together_client = Together(api_key=os.getenv("TOGETHER_API_KEY"))
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
```
```typescript TypeScript theme={null}
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 });
```
## AI Agent with MCP Integration
Now we'll create an intelligent agent that uses Together AI's powerful LLMs with Klavis MCP servers. This agent will:
1. **Discover Tools**: Automatically find available tools from MCP servers
2. **Function Calling**: Use Together AI's function calling capabilities
3. **Tool Execution**: Execute tools through Klavis API
4. **Smart Responses**: Generate intelligent responses based on tool results
```python Python theme={null}
class Agent:
def __init__(self, together_client, klavis_client, mcp_server_url, model="meta-llama/Llama-3.3-70B-Instruct-Turbo"):
self.together = together_client
self.klavis = klavis_client
self.mcp_server_url = mcp_server_url
self.model = model
print(f"š¤ Agent initialized with Together AI model: {self.model}")
def process_request(self, user_message):
# 1. Get available tools
mcp_tools = self.klavis.mcp_server.list_tools(
server_url=self.mcp_server_url,
format=ToolFormat.OPENAI
)
# 2. Call LLM with tools
messages = [
{"role": "system", "content": "You are a helpful AI assistant with access to various tools."},
{"role": "user", "content": user_message}
]
response = self.together.chat.completions.create(
model=self.model,
messages=messages,
tools=mcp_tools.tools
)
assistant_message = response.choices[0].message
messages.append(assistant_message)
# 3. If LLM wants to use tools
if assistant_message.tool_calls:
# Execute each tool call
for tool_call in assistant_message.tool_calls:
tool_name = tool_call.function.name
tool_args = json.loads(tool_call.function.arguments)
print(f"š ļø Calling tool: {tool_name} with args: {tool_args}")
# Call tool via Klavis SDK
tool_result = self.klavis.mcp_server.call_tools(
server_url=self.mcp_server_url,
tool_name=tool_name,
tool_args=tool_args
)
messages.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": str(tool_result)
})
# 4. Get final response from LLM
final_response = self.together.chat.completions.create(
model=self.model,
messages=messages
)
return final_response.choices[0].message.content
# If no tools needed, return the assistant message directly
return assistant_message.content
```
```typescript TypeScript theme={null}
class Agent {
private together: Together;
private klavis: KlavisClient;
private mcpServerUrl: string;
private model: string;
constructor(togetherClient: Together, klavisClient: KlavisClient, mcpServerUrl: string, model: string = "meta-llama/Llama-3.3-70B-Instruct-Turbo") {
this.together = togetherClient;
this.klavis = klavisClient;
this.mcpServerUrl = mcpServerUrl;
this.model = model;
console.log(`š¤ Agent initialized with Together AI model: ${this.model}`);
}
async processRequest(userMessage: string) {
// 1. Get available tools
const mcpTools = await this.klavis.mcpServer.listTools({
serverUrl: this.mcpServerUrl,
format: Klavis.ToolFormat.Openai
});
// 2. Call LLM with tools
const messages = [
{ role: "system", content: "You are a helpful AI assistant with access to various tools." },
{ role: "user", content: userMessage }
];
const response = await this.together.chat.completions.create({
model: this.model,
messages: messages,
tools: mcpTools.tools
});
const assistantMessage = response.choices[0].message;
messages.push(assistantMessage);
// 3. If LLM wants to use tools
if (assistantMessage.tool_calls) {
// Execute each tool call
for (const toolCall of assistantMessage.tool_calls) {
const toolName = toolCall.function.name;
const toolArgs = JSON.parse(toolCall.function.arguments);
console.log(`š ļø Calling tool: ${toolName} with args:`, toolArgs);
// Call tool via Klavis SDK
const toolResult = await this.klavis.mcpServer.callTools({
serverUrl: this.mcpServerUrl,
toolName: toolName,
toolArgs: toolArgs
});
messages.push({
role: "tool",
tool_call_id: toolCall.id,
content: JSON.stringify(toolResult)
});
}
// 4. Get final response from LLM
const finalResponse = await this.together.chat.completions.create({
model: this.model,
messages: messages
});
return finalResponse.choices[0].message.content;
}
// If no tools needed, return the assistant message directly
return assistantMessage.content;
}
}
```
## Use Case Examples
### Example 1: Summarize YouTube Video
Set up Together AI and Klavis API clients
Create a YouTube MCP server instance
Use the agent to analyze and summarize a YouTube video
```python Python theme={null}
# Example YouTube video URL - replace with any video you'd like to analyze
YOUTUBE_VIDEO_URL = "https://www.youtube.com/watch?v=TG6QOa2JJJQ"
# 1. Create YouTube MCP server instance
youtube_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.YOUTUBE,
user_id="1234"
)
# 2. Create an agent with YouTube MCP server
agent = Agent(
together_client=together_client,
klavis_client=klavis_client,
mcp_server_url=youtube_mcp_instance.server_url,
model="meta-llama/Llama-3.3-70B-Instruct-Turbo"
)
# 3. Process the request
response = agent.process_request(
f"Please analyze this YouTube video and provide a comprehensive summary with timestamps: {YOUTUBE_VIDEO_URL}"
)
print(response)
```
```typescript TypeScript theme={null}
// Example YouTube video URL - replace with any video you'd like to analyze
const YOUTUBE_VIDEO_URL = "https://www.youtube.com/watch?v=TG6QOa2JJJQ";
// 1. Create YouTube MCP server instance
const youtubeMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Youtube,
userId: "1234"
});
// 2. Create an agent with YouTube MCP server
const agent = new Agent(
togetherClient,
klavisClient,
youtubeMcpInstance.serverUrl,
"meta-llama/Llama-3.3-70B-Instruct-Turbo"
);
// 3. Process the request
const response = await agent.processRequest(
`Please analyze this YouTube video and provide a comprehensive summary with timestamps: ${YOUTUBE_VIDEO_URL}`
);
console.log(response);
```
### Example 2: Send Email via Gmail
Gmail integration requires OAuth authentication, so you'll need to authorize the application in your browser.
```python Python theme={null}
import webbrowser
# Create Gmail MCP server instance
gmail_mcp_instance = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.GMAIL,
user_id="1234"
)
# Redirect to Gmail OAuth page for authorization
webbrowser.open(gmail_mcp_instance.oauth_url)
print(f"š Opening OAuth authorization for Gmail")
print(f"If you are not redirected automatically, please open this URL: {gmail_mcp_instance.oauth_url}")
# Email configuration
EMAIL_RECIPIENT = "recipient@example.com" # Replace with the recipient's email
EMAIL_SUBJECT = "Greetings from Together AI + Klavis Integration"
EMAIL_BODY = "This is a test email sent using the Together AI and Klavis AI integration. The email was sent automatically by your AI agent!"
# After OAuth authorization is complete, create the Gmail agent
gmail_agent = Agent(
together_client=together_client,
klavis_client=klavis_client,
mcp_server_url=gmail_mcp_instance.server_url,
model="Qwen/Qwen2.5-72B-Instruct-Turbo"
)
# Send the email
response = gmail_agent.process_request(
f"Please send an email to {EMAIL_RECIPIENT} with the subject '{EMAIL_SUBJECT}' and the following body: '{EMAIL_BODY}'"
)
print(response)
```
```typescript TypeScript theme={null}
// Create Gmail MCP server instance
const gmailMcpInstance = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Gmail,
userId: "1234"
});
// Redirect to Gmail OAuth page for authorization
console.log("š Opening OAuth authorization for Gmail");
console.log(`If you are not redirected automatically, please open this URL: ${gmailMcpInstance.oauthUrl}`);
// In a web environment, you might redirect the user
window.open(gmailMcpInstance.oauthUrl);
// Email configuration
const EMAIL_RECIPIENT = "recipient@example.com"; // Replace with the recipient's email
const EMAIL_SUBJECT = "Greetings from Together AI + Klavis Integration";
const EMAIL_BODY = "This is a test email sent using the Together AI and Klavis AI integration. The email was sent automatically by your AI agent!";
// After OAuth authorization is complete, create the Gmail agent
const gmailAgent = new Agent(
togetherClient,
klavisClient,
gmailMcpInstance.serverUrl,
"Qwen/Qwen2.5-72B-Instruct-Turbo"
);
// Send the email
const response = await gmailAgent.processRequest(
`Please send an email to ${EMAIL_RECIPIENT} with the subject '${EMAIL_SUBJECT}' and the following body: '${EMAIL_BODY}'`
);
console.log(response);
```
## Next Steps
Try other available servers like Slack, Notion, CRM etc.
Test various Together AI models for different use cases.
Create sophisticated agents that combine multiple services
Scale these patterns for production applications
## Useful Resources
* [Together AI Documentation](https://docs.together.ai/)
* [Klavis AI Documentation](https://www.klavis.ai/docs/)
* [MCP Protocol Specification](https://modelcontextprotocol.io/)
* [Together AI Models](https://docs.together.ai/docs/inference-models)
* [Klavis MCP Servers](/mcp-server)
**Happy building with Together AI and Klavis!** š
# Klavis API Key
Source: https://www.klavis.ai/docs/api-reference/api_key
How to get your API key for authentication
### Personal Account
1. Go to **[Dashboard](https://www.klavis.ai/home/)**
2. Navigate to **API KEY** section
### Team Account
1. Go to **[Dashboard](https://www.klavis.ai/home/)**
2. Navigate to **Team**
3. Access **API KEY** section
# Introduction
Source: https://www.klavis.ai/docs/api-reference/introduction
Klavis provides API for developers to integrate MCP to your AI application.
## Base URL
The Klavis API is built on REST principles. We enforce HTTPS in every request to improve data security, integrity, and privacy. The API does not support HTTP.
All requests contain the following base URL:
```bash theme={null}
https://api.klavis.ai
```
## Authentication
To authenticate you need to add an Authorization header with the contents of the header being Bearer key\_123456789 where key\_123456789 is your API Key.
```bash theme={null}
Authorization: Bearer key_123456789
```
## Response codes
Klavis uses standard HTTP codes to indicate the success or failure of your requests.
In general, 2xx HTTP codes correspond to success, 4xx codes are for user-related failures, and 5xx codes are for infrastructure issues.
| Status | Description |
| ------ | --------------------------------------- |
| 200 | Successful request. |
| 400 | Check that the parameters were correct. |
| 401 | The API key used was missing. |
| 403 | The API key used was invalid. |
| 404 | The resource was not found. |
| 429 | The rate limit was exceeded. |
| 5xx | Indicates an error with Klavis servers. |
Check Error Codes for a comprehensive breakdown of all possible API errors.
## Rate limit
The default maximum rate limit is 2 requests per second. This number can be increased for trusted senders by request. After that, you'll hit the rate limit and receive a 429 response error code.
# Call Tool
Source: https://www.klavis.ai/docs/api-reference/mcp-server/call-tool
post /mcp-server/call-tool
Calls a tool on a specific remote MCP server, used for function calling. Eliminates the need for manual MCP code implementation.
Under the hood, Klavis will instantiates an MCP client and establishes a connection with the remote MCP server to call the tool.
# Create
Source: https://www.klavis.ai/docs/api-reference/mcp-server/create-a-self-hosted-mcp-server-instance
post /mcp-server/self-hosted/instance/create
Creates an instance id for a self-hosted MCP server,
validating the request with an API key and user details.
The main purpose of this endpoint is to create an instance id for a self-hosted MCP server.
The instance id is used to identify and store the auth metadata in the database.
Returns the existing instance id if it already exists for the user.
# Create
Source: https://www.klavis.ai/docs/api-reference/mcp-server/create-a-server-instance
post /mcp-server/instance/create
Creates a URL for a specified MCP server,
validating the request with an API key and user details.
Returns the existing server URL if it already exists for the user.
If OAuth is configured for the server, also returns the base OAuth authorization URL.
Note that some servers have hundreds of tools and therefore only expose the Strata tools.
# Delete
Source: https://www.klavis.ai/docs/api-reference/mcp-server/delete-a-server-instance
delete /mcp-server/instance/{instanceId}
Completely removes a server connection instance using its unique ID,
deleting all associated data from the system.
# Delete Instance Auth
Source: https://www.klavis.ai/docs/api-reference/mcp-server/delete-instance_auth
delete /mcp-server/instance/{instanceId}/auth
Deletes authentication data for a specific server connection instance.
# Get All Servers
Source: https://www.klavis.ai/docs/api-reference/mcp-server/get-all-servers
get /mcp-server/servers
Get all MCP servers with their basic information including id, name, description, and tools.
# Get Instance Auth
Source: https://www.klavis.ai/docs/api-reference/mcp-server/get-instance_auth
get /mcp-server/instance/{instanceId}/auth
Retrieves the auth data for a specific integration instance that the API key owner controls.
Includes access token, refresh token, and other authentication data.
This endpoint includes proper ownership verification to ensure users can only access
authentication data for integration instances they own. It also handles token refresh if needed.
# Get
Source: https://www.klavis.ai/docs/api-reference/mcp-server/get-server-instance
get /mcp-server/instance/{instanceId}
Checks the details of a specific server connection instance using its unique ID and API key,
returning server details like authentication status and associated server/platform info.
# Get Tools
Source: https://www.klavis.ai/docs/api-reference/mcp-server/get-tools
get /mcp-server/tools/{serverName}
Get tools information for any MCP server.
# List Tools
Source: https://www.klavis.ai/docs/api-reference/mcp-server/list-tools
post /mcp-server/list-tools
Lists all tools available for a specific remote MCP server in various AI model formats.
This eliminates the need for manual MCP code implementation and format conversion.
Under the hood, Klavis instantiates an MCP client and establishes a connection
with the remote MCP server to retrieve available tools.
# Set Instance Auth
Source: https://www.klavis.ai/docs/api-reference/mcp-server/set-instance_auth
post /mcp-server/instance/set-auth
Sets authentication data for a specific integration instance.
Accepts either API key authentication or general authentication data.
This updates the auth_metadata for the specified integration instance.
# Authorize Airtable
Source: https://www.klavis.ai/docs/api-reference/oauth/airtable-oauth/authorize-airtable
get /oauth/airtable/authorize
Start Airtable OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (space-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Asana
Source: https://www.klavis.ai/docs/api-reference/oauth/asana-oauth/authorize-asana
get /oauth/asana/authorize
Start Asana OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Attio
Source: https://www.klavis.ai/docs/api-reference/oauth/attio-oauth/authorize-attio
get /oauth/attio/authorize
Start Attio OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Box
Source: https://www.klavis.ai/docs/api-reference/oauth/box-oauth/authorize-box
get /oauth/box/authorize
Start Box OAuth 2.0 flow
# Authorize Calcom
Source: https://www.klavis.ai/docs/api-reference/oauth/calcom-oauth/authorize-calcom
get /oauth/calcom/authorize
Start Cal.com OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Canva
Source: https://www.klavis.ai/docs/api-reference/oauth/canva-oauth/authorize-canva
get /oauth/canva/authorize
Start Canva OAuth flow with PKCE
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (space-separated, e.g., "design:meta:read profile:read")
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Clickup
Source: https://www.klavis.ai/docs/api-reference/oauth/clickup-oauth/authorize-clickup
get /oauth/clickup/authorize
Start ClickUp OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Close
Source: https://www.klavis.ai/docs/api-reference/oauth/close-oauth/authorize-close
get /oauth/close/authorize
Start Close OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Confluence
Source: https://www.klavis.ai/docs/api-reference/oauth/confluence-oauth/authorize-confluence
get /oauth/confluence/authorize
Start Confluence OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Dialpad
Source: https://www.klavis.ai/docs/api-reference/oauth/dialpad-oauth/authorize-dialpad
get /oauth/dialpad/authorize
Start Dialpad OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (space-separated)
- redirect_url: Optional URL to redirect to after authorization completes
- code_challenge: PKCE code challenge for enhanced security
- code_challenge_method: PKCE code challenge method
# Authorize Docusign
Source: https://www.klavis.ai/docs/api-reference/oauth/docusign-oauth/authorize-docusign
get /oauth/docusign/authorize
Start DocuSign OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Dropbox
Source: https://www.klavis.ai/docs/api-reference/oauth/dropbox-oauth/authorize-dropbox
get /oauth/dropbox/authorize
Start Dropbox OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (space-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Figma
Source: https://www.klavis.ai/docs/api-reference/oauth/figma-oauth/authorize-figma
get /oauth/figma/authorize
Start Figma OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (space-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Gcalendar
Source: https://www.klavis.ai/docs/api-reference/oauth/gcalendar-oauth/authorize-gcalendar
get /oauth/gcalendar/authorize
Start Google Calendar OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Gdocs
Source: https://www.klavis.ai/docs/api-reference/oauth/gdocs-oauth/authorize-gdocs
get /oauth/gdocs/authorize
Start Google Docs OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Gdrive
Source: https://www.klavis.ai/docs/api-reference/oauth/gdrive-oauth/authorize-gdrive
get /oauth/gdrive/authorize
Start Google Drive OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Github
Source: https://www.klavis.ai/docs/api-reference/oauth/github-oauth/authorize-github
get /oauth/github/authorize
Start GitHub OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Gitlab
Source: https://www.klavis.ai/docs/api-reference/oauth/gitlab-oauth/authorize-gitlab
get /oauth/gitlab/authorize
Start GitLab OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (space-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Gmail
Source: https://www.klavis.ai/docs/api-reference/oauth/gmail-oauth/authorize-gmail
get /oauth/gmail/authorize
Start Gmail OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Gsheets
Source: https://www.klavis.ai/docs/api-reference/oauth/gsheets-oauth/authorize-gsheets
get /oauth/gsheets/authorize
Start Google Sheets OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Hubspot
Source: https://www.klavis.ai/docs/api-reference/oauth/hubspot-oauth/authorize-hubspot
get /oauth/hubspot/authorize
Start HubSpot OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (space-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Jira
Source: https://www.klavis.ai/docs/api-reference/oauth/jira-oauth/authorize-jira
get /oauth/jira/authorize
Start Jira OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Klaviyo
Source: https://www.klavis.ai/docs/api-reference/oauth/klaviyo-oauth/authorize-klaviyo
get /oauth/klaviyo/authorize
# Authorize Linear
Source: https://www.klavis.ai/docs/api-reference/oauth/linear-oauth/authorize-linear
get /oauth/linear/authorize
Start Linear OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Linkedin
Source: https://www.klavis.ai/docs/api-reference/oauth/linkedin-oauth/authorize-linkedin
get /oauth/linkedin/authorize
Start LinkedIn OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Notion
Source: https://www.klavis.ai/docs/api-reference/oauth/notion-oauth/authorize-notion
get /oauth/notion/authorize
Start Notion OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize OneDrive
Source: https://www.klavis.ai/docs/api-reference/oauth/onedrive-oauth/authorize-onedrive
get /oauth/onedrive/authorize
# Authorize Outlook
Source: https://www.klavis.ai/docs/api-reference/oauth/outlook-oauth/authorize-outlook
get /oauth/outlook/authorize
# Authorize Pagerduty
Source: https://www.klavis.ai/docs/api-reference/oauth/pagerduty-oauth/authorize-pagerduty
get /oauth/pagerduty/authorize
Start PagerDuty OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Pipedrive
Source: https://www.klavis.ai/docs/api-reference/oauth/pipedrive-oauth/authorize-pipedrive
get /oauth/pipedrive/authorize
Start Pipedrive OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (space-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Quickbooks
Source: https://www.klavis.ai/docs/api-reference/oauth/quickbooks-oauth/authorize-quickbooks
get /oauth/quickbooks/authorize
Start QuickBooks OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- environment: QuickBooks environment to authorize ('sandbox' default)
- scope: Optional scopes to request (space-separated). Default is 'com.intuit.quickbooks.accounting'
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Salesforce
Source: https://www.klavis.ai/docs/api-reference/oauth/salesforce-oauth/authorize-salesforce
get /oauth/salesforce/authorize
Start Salesforce OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (space-separated)
- redirect_url: Optional URL to redirect to after authorization completes
- instance_url: Optional Salesforce instance URL for sandbox or custom domains
# null
Source: https://www.klavis.ai/docs/api-reference/oauth/shopify-oauth/authorize-shopify
get /oauth/shopify/authorize
# Authorize Slack
Source: https://www.klavis.ai/docs/api-reference/oauth/slack-oauth/authorize-slack
get /oauth/slack/authorize
Start Slack OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- user_scope: Optional user-specific scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Stripe Connect
Source: https://www.klavis.ai/docs/api-reference/oauth/stripe-connect-oauth/authorize-stripe-connect
get /oauth/stripe/authorize
Start Stripe Connect OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (space-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Supabase
Source: https://www.klavis.ai/docs/api-reference/oauth/supabase-oauth/authorize-supabase
get /oauth/supabase/authorize
Start Supabase OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Vercel
Source: https://www.klavis.ai/docs/api-reference/oauth/vercel-oauth/authorize-vercel
get /oauth/vercel/authorize
Start Vercel OAuth flow using integration pattern
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- client_slug: Vercel integration slug (required for integration-based OAuth)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Wordpress
Source: https://www.klavis.ai/docs/api-reference/oauth/wordpress-oauth/authorize-wordpress
get /oauth/wordpress/authorize
Start WordPress OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (comma-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Xero
Source: https://www.klavis.ai/docs/api-reference/oauth/xero-oauth/authorize-xero
get /oauth/xero/authorize
Start Xero OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (space-separated)
- redirect_url: Optional URL to redirect to after authorization completes
# Authorize Zendesk
Source: https://www.klavis.ai/docs/api-reference/oauth/zendesk-oauth/authorize-zendesk
get /oauth/zendesk/authorize
Start Zendesk OAuth flow
Parameters:
- instance_id: Identifier for the instance requesting authorization
- client_id: Optional client ID for white labeling
- scope: Optional scopes to request (space-separated)
- redirect_url: Optional URL to redirect to after authorization completes
- subdomain: Zendesk subdomain for the account being connected
# Add
Source: https://www.klavis.ai/docs/api-reference/strata/add
post /mcp-server/strata/add
Add servers to an existing Strata MCP server.
Note: After adding servers, you need to reconnect the MCP server so that list_tool can be updated with the new servers.
Parameters:
- servers: Can be 'ALL' to add all available servers, a list of specific server names, or null to add no servers
- externalServers: Optional list of external MCP servers to validate and add
# Create
Source: https://www.klavis.ai/docs/api-reference/strata/create
post /mcp-server/strata/create
Create a Strata MCP server.
Parameters:
- servers: Can be 'ALL' to add all available Klavis integration, a list of specific server names, or null to add no servers
- externalServers: Optional list of external MCP servers to validate and add
# Delete
Source: https://www.klavis.ai/docs/api-reference/strata/delete
delete /mcp-server/strata/{strataId}/servers
Delete servers from an existing Strata MCP server.
Note: After deleting servers, you need to reconnect the MCP server so that list_tool can be updated to reflect the removed servers.
Parameters:
- strataId: The strata server ID (path parameter)
- servers: Can be 'ALL' to delete all available Klavis integration, a list of specific server names, or null to delete no servers
- externalServers: Query parameter - comma-separated list of external server names to delete
Returns separate lists for deleted Klavis servers and deleted external servers.
# Delete Strata Auth
Source: https://www.klavis.ai/docs/api-reference/strata/delete-strata-auth
delete /mcp-server/strata/{strataId}/auth/{serverName}
Deletes authentication data for a specific integration within a Strata MCP server.
This will clear the stored authentication credentials, effectively unauthenticating the server.
# Get
Source: https://www.klavis.ai/docs/api-reference/strata/get
get /mcp-server/strata/{strataId}
Get information about an existing Strata MCP server instance.
Returns the strata URL, connected klavis servers, connected external servers (with URLs),
and authentication URLs for klavis servers.
# Get Strata Auth
Source: https://www.klavis.ai/docs/api-reference/strata/get-strata-auth
get /mcp-server/strata/{strataId}/auth/{serverName}
Retrieves authentication data for a specific integration within a Strata MCP server.
Returns the authentication data if available, along with authentication status.
# List Raw Actions
Source: https://www.klavis.ai/docs/api-reference/strata/list-raw-actions
get /mcp-server/strata/{strataId}/raw-actions
Fetch raw actions (all underlying actions) for a specific integration within a Strata MCP instance.
# Set Strata Auth
Source: https://www.klavis.ai/docs/api-reference/strata/set-strata-auth
post /mcp-server/strata/set-auth
Sets authentication data for a specific integration within a Strata MCP server.
Accepts either API key authentication or general authentication data.
# Delete User
Source: https://www.klavis.ai/docs/api-reference/user/delete-user
delete /user/{userId}
Delete a user and all associated data by user_id.
Users cannot delete their own accounts.
This operation will permanently remove all user data.
# Delete User Auth
Source: https://www.klavis.ai/docs/api-reference/user/delete-user-auth
delete /user/{userId}/auth/{serverName}
Deletes authentication data for a specific integration for a user.
This will clear the stored authentication credentials, effectively unauthenticating the integration.
# Get All Users
Source: https://www.klavis.ai/docs/api-reference/user/get-all-users
get /user/
Retrieve all users that have been created under your account, with support for pagination.
# Get User
Source: https://www.klavis.ai/docs/api-reference/user/get-user
get /user/{userId}
Get user information by user_id.
# Get User Auth
Source: https://www.klavis.ai/docs/api-reference/user/get-user-auth
get /user/{userId}/auth/{serverName}
Retrieves authentication data for a specific integration for a user.
Returns the authentication data if available, along with authentication status.
Includes token refresh handling if needed.
# Get User Integrations
Source: https://www.klavis.ai/docs/api-reference/user/get-user-integrations
get /user/{userId}/integrations
Get all available integrations (MCP server names) by user ID.
Returns a list of integration names as McpServerName types.
# Set User Auth
Source: https://www.klavis.ai/docs/api-reference/user/set-user-auth
post /user/set-auth
Sets authentication data for a specific integration for a user.
Accepts either API key authentication or general authentication data.
This updates the auth_metadata for the specified user's integration instance.
# Create
Source: https://www.klavis.ai/docs/api-reference/white-labeling/create
post /white-labeling/create
Saves OAuth white labeling information, or updates existing information if the `client_id` matches.
# Get
Source: https://www.klavis.ai/docs/api-reference/white-labeling/get
get /white-labeling/get/{client_id}
Retrieves white labeling information for a specific OAuth client ID.
# API Key
Source: https://www.klavis.ai/docs/auth/api-key
## MCP Servers that require API Key Authentication
The following MCP servers use API key authentication and do not support OAuth:
* **Cloudflare** - Requires Cloudflare API token
* **Discord** - Requires Discord bot token
* **ElevenLabs** - Requires ElevenLabs API key
* **PostHog** - Requires PostHog API key
* **SendGrid** - Requires SendGrid API key
# OAuth
Source: https://www.klavis.ai/docs/auth/oauth
## What is OAuth?
OAuth (Open Authorization) is an open standard protocol that allows third-party applications to access resources on behalf of users without exposing their credentials. Klavis AI implements OAuth 2.0 to securely connect with services like GitHub, Slack, Gmail, Notion, and more.
## MCP Servers that support OAuth Authentication
For detailed OAuth scope and how to create your own OAuth app, see our [OAuth knowledge](/knowledge-base/oauth_app/oauth-scopes).
The following MCP servers support OAuth authentication:
* **Airtable** - OAuth 2.0 integration
* **Asana** - OAuth 2.0 integration
* **Attio** - OAuth 2.0 integration
* **Box** - OAuth 2.0 integration
* **Cal.com** - OAuth 2.0 integration
* **Canva** - OAuth 2.0 integration
* **ClickUp** - OAuth 2.0 integration
* **Close** - OAuth 2.0 integration
* **Confluence** - OAuth 2.0 integration
* **Dialpad** - OAuth 2.0 integration
* **DocuSign** - OAuth 2.0 integration
* **Dropbox** - OAuth 2.0 integration
* **Figma** - OAuth 2.0 integration
* **GitHub** - OAuth 2.0 integration
* **GitLab** - OAuth 2.0 integration
* **Gmail** - OAuth 2.0 integration
* **Google Calendar** - OAuth 2.0 integration
* **Google Docs** - OAuth 2.0 integration
* **Google Drive** - OAuth 2.0 integration
* **Google Sheets** - OAuth 2.0 integration
* **HubSpot** - OAuth 2.0 integration
* **Jira** - OAuth 2.0 integration
* **Klaviyo** - OAuth 2.0 integration
* **Linear** - OAuth 2.0 integration
* **LinkedIn** - OAuth 2.0 integration
* **Notion** - OAuth 2.0 integration
* **PagerDuty** - OAuth 2.0 integration
* **Pipedrive** - OAuth 2.0 integration
* **QuickBooks** - OAuth 2.0 integration
* **Salesforce** - OAuth 2.0 integration
* **Slack** - OAuth 2.0 integration
* **Stripe Connect** - OAuth 2.0 integration
* **Supabase** - OAuth 2.0 integration
* **Vercel** - OAuth 2.0 integration
* **WordPress** - OAuth 2.0 integration
* **Xero** - OAuth 2.0 integration
* **Zendesk** - OAuth 2.0 integration
# White-label
Source: https://www.klavis.ai/docs/auth/white-label
White-label allows you to integrate our OAuth flows with your own branding and custom OAuth applications
For detailed OAuth scope and how to create your own OAuth app, see our [OAuth knowledge](/knowledge-base/oauth_app/oauth-scopes).
## What is White-label?
White-label allows you to customize the authentication experience with your own branding. When enabled, users will see your application name, logo, and other brand elements during the OAuth flow instead of Klavis AI's.
## OAuth Flow (w/ white-label)
```mermaid theme={null}
sequenceDiagram
actor EndUser
participant ClientApp as Your App
participant KlavisAI as Klavis AI
participant ThirdPartyIdP as Third-party App
%% --- OAuth Flow Initiation ---
EndUser->>ClientApp: 1. Initiates action in Your App (e.g., "Connect my Account").
ClientApp->>KlavisAI: 2. Requests Klavis AI to start OAuth flow.
activate KlavisAI
Note over KlavisAI: Klavis AI retrieves the Your App's Config
KlavisAI->>EndUser: 3. Redirects End-User's browser to Third-party authorization endpoint.
deactivate KlavisAI
activate EndUser
EndUser->>ThirdPartyIdP: 4. Browser navigates to Third-party authorization URL.
activate ThirdPartyIdP
ThirdPartyIdP-->>EndUser: 5. Third-party App presents its Login & Consent screen with Your App Info and Logo.
EndUser->>ThirdPartyIdP: 6. End-User authenticates with Third-party App & grants consent.
deactivate EndUser
ThirdPartyIdP-->>KlavisAI: 7. Third-party App redirects Klavis AI callback URI.
deactivate ThirdPartyIdP
%% --- Token Exchange (Klavis AI with Third-party) ---
KlavisAI->>ThirdPartyIdP: 8. Klavis AI exchanges Authorization Code for Access Token.
activate ThirdPartyIdP
ThirdPartyIdP-->>KlavisAI: 9. Third-party returns Access/Refresh Token to Klavis AI.
deactivate ThirdPartyIdP
KlavisAI->>EndUser: 10. OAuth White Labeling succeeds.
```
## Implementation
### Setting Up White-label
To set up white-label for your OAuth integrations:
Register your application with the third-party service (GitHub, Slack, etc.) to obtain your client ID and client secret.
Go to the Klavis AI white label configuration page:
[https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
Make sure to add the callback url to your app's OAuth allow list.
Redirect users to the Klavis AI OAuth authorization endpoint with your client ID:
```javascript without SDK theme={null}
// Example: Initiating GitHub OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/github/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating GitHub OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Github,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating GitHub OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.GITHUB,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
You can also specify scope and redirect\_url in the authUrl, check the api reference for more details.
For simplicity, you can use the default callback URL: [https://api.klavis.ai/oauth/\{server\_name}/callback](https://api.klavis.ai/oauth/\{server_name}/callback),
as shown in the previous step. This is the endpoint where we handle user credentials for authentication.
However, some OAuth consent screens (such as GitHub's) display the callback URL to the user. If this URL doesn't match your application's domain, it can appear untrustworthy.
To address this, you can use a callback URL under your own domain and set up a redirectāeither via DNS or within your applicationāthat forwards requests to:
[https://api.klavis.ai/oauth/\{server\_name}/callback](https://api.klavis.ai/oauth/\{server_name}/callback). Below is an example using FastAPI to simply redirect from your Github oauth application to Klavis oauth service in python -
```python theme={null}
@app.get("/github/redirect")
async def redirect_to_jira_callback(request: Request):
target_url = "https://api.klavis.ai/oauth/github/callback"
query_params = request.query_params
if query_params:
query_string = str(query_params)
target_url = f"{target_url}?{query_string}"
return RedirectResponse(url=target_url)
```
For technical assistance with OAuth implementation or white-label, please join our Discord community.
# MCP
Source: https://www.klavis.ai/docs/concepts/mcp
Understanding the Model Context Protocol and how it enables AI agents to interact with external systems
# What is Model Context Protocol (MCP)?
The **Model Context Protocol (MCP)** is an open standard that unifies how AI models communicate with external tools and services. It acts as a bridge between Large Language Models (LLMs) and the real world, enabling AI agents to interact with databases, APIs, files, and other systems in a standardized way.
## How MCP Works
MCP follows a simple **client-server architecture**:
* **MCP Client**: The AI assistant or application (like Claude Desktop, Cursor, or your custom AI agent)
* **MCP Server**: A specialized backend that exposes tools to interact with external systems
* **Tools**: Individual functions that the AI can call to perform specific actions
```mermaid theme={null}
graph LR
A[AI Agent] -->|Request| B[MCP Client]
B -->|Tool Call| C[MCP Server]
C -->|API Call| D[External Service]
D -->|Response| C
C -->|Result| B
B -->|Context| A
```
## Key Benefits
One protocol for all external integrations - no more custom, one-off connections
Access to 100+ pre-built tools across CRM, productivity, and development platforms
Built-in OAuth flows and secure credential management
Production-ready hosted infrastructure with self-hosting options
## MCP Server Types
### Hosted MCP Servers (Recommended)
Klavis AI provides **production-ready hosted MCP servers** that eliminate setup complexity:
* No infrastructure management
* Built-in OAuth authentication
* Automatic updates and maintenance
* 99.9% uptime SLA
```python theme={null}
from klavis import Klavis
klavis = Klavis(api_key="your-api-key")
server = klavis.mcp_server.create_strata_server(...)
```
### Self-Hosted MCP Servers
For custom requirements or on-premises deployments:
```bash theme={null}
# Run any MCP server with Docker
docker run -p 5000:5000 ghcr.io/klavis-ai/gmail-mcp-server:latest
```
## Available MCP Integrations
Klavis AI offers 100+ MCP servers across different categories:
Browse our complete catalog of MCP server integrations
## Getting Started
Get up and running in under 5 minutes
## Learn More
Read the official Model Context Protocol specification
Explore our open-source repo
Join our developer community
# Strata
Source: https://www.klavis.ai/docs/concepts/strata
One MCP server for AI agents to use tools progressively at any scale
# What is Strata?
**Strata** is one MCP server that guides AI agents use tools reliably at any complexity, instead of overwhelming them with everything at once, it was designed by thinking human interacting with tools, solving the three major problems that plague AI agents today:
* **Tool Overload**: Too many tools cause LLM choice paralysis
* **Context Overload**: Long tool lists blow up token counts and costs
* **Coverage Gap**: Most servers are stuck at 40\~50 tools, limiting what you can build
You can use Strata via our [website](https://www.klavis.ai/home/mcp-servers), [API](https://www.klavis.ai/docs/api-reference/strata/create), or even [open source](https://github.com/Klavis-AI/klavis) on your own data!
## Video Tutorial
Watch this video tutorial for a complete understanding of how Strata works:
## Text Tutorial
Check out this [shared Claude conversation](https://claude.ai/share/9b44a192-9f2d-46e2-a875-ef905c457070) to see Strata in action!
### 1. Discover Server Categories or Actions
**`discover_server_categories_or_actions`** - find relevant categories or actions based on user intent. No semantic search!
**Description**: **PREFERRED STARTING POINT**. Discover available categories or actions based on user query. Try this tool first when exploring what actions are available across servers. This is the primary entry point for exploring available actions and should be used before other search methods. The output will be a list of servers with detail level and details.
If detail level is 'categories\_only', the details will be a list of category names only. Next step prefer to use get\_category\_actions tool to get the actions for the categories.
If detail level is 'full\_details', the details will be a list of category names with their actions details included. This happens when the server has only a few actions. Next step prefer to use execute\_action tool to execute the actions.
If detail level is 'categories\_and\_actions', the details will be a list of category names and action names. This happens when using external tools. Next step prefer to use get\_action\_details tool to get the details of the actions.
**Parameters**:
* `user_query` (string, required): Natural language user query to filter results.
* `server_names` (array, required): List of server names to discover categories or actions.
### 2. Get Category Actions
**`get_category_actions`** - retrieve all action names within specified categories.
**Description**: Get a comprehensive overview of API actions available within specific categories. Use this tool if you want to explore what actions are available in particular service categories or get a detailed view of category capabilities. \*\* Important \*\*: It should only be called after you get the server categories from the discover\_server\_categories tool.
**Parameters**:
* `category_names` (array, required): List of categories to get actions for
### 3. Get Action Details
**`get_action_details`** - get full schema and parameters for a specific action.
**Description**: Get detailed information about a specific action, including required and optional parameters. Must provide category name and action name. \*\* Important \*\*: It should only be called after you get the server categories from previous tool calls.
**Parameters**:
* `category_name` (string, required): The name of the category
* `action_name` (string, required): The name of the action/operation within the category
### 4. Execute Action
**`execute_action`** - run actions with parameters and get results.
**Description**: Execute a specific action with the provided parameters. Must provide server name, action name, and action parameters. \*\* Important \*\*: It should only be called after you get the action details from the get\_action\_details tool.
**Parameters**:
* `server_name` (string, required): The name of the server
* `category_name` (string, required): The name of the category to execute the action for
* `action_name` (string, required): The name of the action/operation to execute
* `path_params` (string, optional): JSON string containing path parameters for the action
* `query_params` (string, optional): JSON string containing query parameters for the action
* `body_schema` (string, optional, default: "{}"): JSON string containing request body for actions
* `include_output_fields` (array, optional): Optional but strongly recommended when you know the response\_schema of this action from previous tool calls: Array of field paths to include in the response. Only these fields will be returned. Use dot notation for nested fields (e.g., "author.displayName").
* `maximum_output_characters` (integer, optional): Optional: Maximum number of characters to return in the response. If the response exceeds this limit, it will be truncated. Prefer include\_output\_fields over this.
### 5. Search Documentation
**`search_documentation`** - find relevant information only when needed.
**Description**: **SECONDARY OPTION**: Use this tool only when discover\_server\_categories doesn't provide sufficient detail or when you need to search within a specific server's documentation. Search for server action documentations by category, operation, tags, or functionality using keyword matching. This is not a natural language search - it matches exact keywords and phrases. Returns endpoints ranked by relevance. Use a few targeted keywords to find the best matches. Common patterns: category names ('projects', 'users', 'pipelines'), actions ('create', 'delete', 'list', 'get'), or combinations ('create user', 'list projects'). The search algorithm uses smart scoring to prevent verbose description fields from overwhelming results.
**Parameters**:
* `query` (string, required): Search keywords that match API documentation terms. Best practices: (1) Use resource names like 'users', 'projects', 'files', (2) Add actions for precision like 'user create' or 'project delete', (3) Avoid filler words like 'how to', 'show me', 'all the' - focus on the core terms that appear in endpoint names and descriptions.
* `server_name` (string, required): Name of the server to search within.
* `max_results` (integer, optional, default: 10, minimum: 1, maximum: 50): Number of results to return. Default: 10
### 6. Handle Auth Failure
**`handle_auth_failure`** - handle authentication only when needed.
**Description**: Handle authentication failures that occur when executing actions. CRITICAL: This tool should ONLY be called when execute\_action fails specifically due to authentication issues (401 Unauthorized, invalid credentials, expired tokens, etc.). DO NOT call this tool to check authentication status or for any other purpose. Usage: (1) When execute\_action returns an authentication error, call this tool with 'get\_auth\_url' to get authentication instructions. (2) When user provides authentication data after a failure, call this tool with 'save\_auth\_data' to save the credentials. NEVER call this tool if the failure is NOT an authentication failure (e.g., 404 Not Found, 500 Internal Server Error, etc.).
**Parameters**:
* `server_name` (string, required): The name of the server that failed authentication during execute\_action
* `intention` (string, required, enum: \["get\_auth\_url", "save\_auth\_data"]): Use 'get\_auth\_url' when execute\_action fails with authentication errors to get authentication instructions. Use 'save\_auth\_data' when user provides authentication credentials after an authentication failure.
* `auth_data` (object, optional): Authentication data provided by user after an authentication failure (e.g., `{"token": "...", "api_key": "..."}`). Only used with 'save\_auth\_data' intention when resolving authentication failures.
## Evaluation
Strata delivers real results:
* **MCPMark Benchmark**: Achieves **+15.2% higher pass\@1 rate** vs the official GitHub server and **+13.4% higher pass\@1 rate** vs the official Notion server. ([Source](https://mcpmark.ai/leaderboard/mcp))
* **Human Evaluation**: Hits **83%+ accuracy** across >2k real world queries evaluation sets
## Next Steps
Create your first Strata server in minutes
Explore the complete Strata API
# Klavis Security
Source: https://www.klavis.ai/docs/enterprise-security/klavis-security
Comprehensive security layer for MCP integrations protecting against prompt injection, tool poisoning, and other emerging threats.
## Overview
Klavis Guardrails is a comprehensive security layer designed to protect MCP (Model Context Protocol) integrations from emerging threats. It operates as an intelligent proxy between MCP clients and servers, providing real-time threat detection and policy enforcement.
## The Security Challenge
MCP's architecture amplifies security risks by exposing tools, resources, and prompts directly to AI agents. Recent vulnerabilities demonstrate critical flaws:
* **Prompt Injection via Tool Descriptions**: Malicious instructions embedded in MCP tool metadata
* **Cross-Repository Information Leakage**: Agents coerced into accessing private repositories
* **Command Injection and RCE**: Basic security flaws allowing arbitrary code execution
* **Credential Theft**: MCP servers storing OAuth tokens become high-value targets
## Security Architecture
Klavis Guardrails operates as a security proxy that intercepts, analyzes, and enforces policies on all MCP communication in real-time with four key protection mechanisms:
**Tool Poisoning Detection**: Monitors MCP tool metadata using behavioral analysis to identify when tools deviate from declared functionality.
**Prompt Injection Prevention**: Uses advanced NLP to analyze prompts for malicious instructions, detecting sophisticated attacks before they reach the model.
**Privilege Escalation Monitoring**: Enforces granular access controls ensuring MCP servers operate under least privilege principles.
**Command Injection Mitigation**: Performs deep inspection of tool invocations with strict allowlists and input sanitization.
## Get Started
**Ready to secure your MCP infrastructure?** Join our beta by [scheduling a 15-minute call](https://cal.com/zihao-lin-u35ykt/15min) with us, or reach out directly at [security@klavis.ai](mailto:security@klavis.ai).
# Installation
Source: https://www.klavis.ai/docs/installation
Install Klavis SDK or use REST API directly
## SDK Installation
```bash Python theme={null}
pip install klavis
```
```bash TypeScript theme={null}
npm install klavis
```
## REST API
```bash theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/instance/create" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{"serverName": "Gmail", "userId": "user123"}'
```
# Introduction
Source: https://www.klavis.ai/docs/introduction
MCP Integration for your AI Application
# What is Klavis?
**Klavis AI is open source MCP integration layers that let AI agents use any tool reliably at any scale. You can use our API to automate workflows across single or multiple apps with managed authentications.**
With Klavis API, you can equip your AI agent with any tools, without the complexity of managing authentication, handling security, or dealing with context overload.
## Get started
Connect any integration in minutes
Explore available MCP servers
Progressive tool discovery across apps
REST endpoints and schemas
# Introduction
Source: https://www.klavis.ai/docs/knowledge-base/introduction
A collection of answers to frequently asked questions about MCP
## Getting Started
A beginner's guide to creating your first MCP server with Gmail as an example.
Learn how to use your Gmail MCP server with OpenAI.
## Use MCP Server
Learn how to integrate Klavis MCP Servers with ChatGPT for enhanced AI workflow experience.
Learn how to integrate Klavis MCP Servers with Claude Code for enhanced AI workflow experience.
Learn how to integrate Klavis MCP Servers with Claude Desktop for enhanced AI workflow experience.
Learn how to integrate Klavis MCP Servers with Cline for enhanced AI workflow experience.
Learn how to integrate Klavis MCP Servers with Continue for enhanced AI workflow experience.
Learn how to integrate Klavis MCP Servers with Cursor IDE for enhanced AI coding experience.
Learn how to integrate Klavis MCP Servers with Gemini CLI for enhanced AI coding experience.
Learn how to integrate Klavis MCP Servers with Kiro for enhanced AI workflow experience.
Learn how to integrate Klavis MCP Servers with n8n for enhanced AI coding experience.
Learn how to integrate Klavis MCP Servers with VS Code IDE for enhanced AI coding experience.
Learn how to integrate Klavis MCP Servers with Windsurf IDE for enhanced AI coding experience.
## OAuth App Setup
Complete reference of OAuth scopes required for each supported application
Step-by-step guide to setting up Airtable OAuth application
Step-by-step guide to setting up Asana OAuth application
Step-by-step guide to setting up Calendly OAuth application
Step-by-step guide to setting up Canva OAuth application
Step-by-step guide to setting up Discord OAuth application
Step-by-step guide to setting up Dropbox OAuth application
Step-by-step guide to setting up Figma OAuth application
Step-by-step guide to setting up Gmail OAuth application
Step-by-step guide to setting up Google Calendar OAuth application
Step-by-step guide to setting up Google Docs OAuth application
Step-by-step guide to setting up Google Drive OAuth application
Step-by-step guide to setting up Google Sheets OAuth application
Step-by-step guide to setting up HubSpot OAuth application
Step-by-step guide to setting up LinkedIn OAuth application
Step-by-step guide to setting up Monday.com OAuth application
Step-by-step guide to setting up Moneybird OAuth application
Step-by-step guide to setting up OneDrive OAuth application
Step-by-step guide to setting up QuickBooks OAuth application
Step-by-step guide to setting up Salesforce OAuth application
Step-by-step guide to setting up Slack OAuth application
Step-by-step guide to setting up Xero OAuth application
# LLM-based Development
Source: https://www.klavis.ai/docs/knowledge-base/llm-based-development
Enhance your AI coding experience with LLM readable documentation.
## Overview
Welcome to the guide on utilizing our specialized `llms.txt` files to enhance your LLM-based coding workflow. Whether youāre using Replit, Cursor, Claude Code, or any other AI coding tool, this page will assist you in leveraging our resources to debug and refine code generated by Klavis.
## Option 1: Copy-paste llms.txt
Copy the [llms.txt](https://raw.githubusercontent.com/Klavis-AI/klavis/refs/heads/main/LLM.md) and paste it in the prompt for your coding assistant.
## Option 2: Install the MCP server
Open a terminal and run the following command to install the MCP server locally:
```bash theme={null}
npx mint-mcp add klavisai
```
Everything will be set up automatically!
# Setting Up Airtable OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/airtable
Complete guide to creating and configuring a Airtable OAuth application
## Prerequisites
* Airtable Account
## Step 1: Create Airtable OAuth Integration
1. Visit [https://airtable.com/create/oauth](https://airtable.com/create/oauth)
2. Click **"Register new OAuth Integration"**
## Step 2: Register an Integration
1. Enter **"Name"**
2. Add redirect URLs: `https://api.klavis.ai/oauth/airtable/callback`
3. Click **"Register Integration"**
Here is an example of Klavis AI OAuth app configuration:
Once registered, Airtable will generate your Client ID and Client Secret. Youāll need these for connecting Klavis AI.
## Step 3: Request Scopes
Klavis Airtable MCP Server uses the following OAuth scopes: `data.records:read, data.records:write, data.recordComments:read, data.recordComments:write, schema.bases:read, schema.bases:write, user.email:read`
1. After registration, add required scopes.
2. Enter Required Info, Then click **"Save Changes"**
You have successfully created an Airtable OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
## (Optional) Step 4: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Airtable OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Airtable **Client ID** and **Client Secret** from Step 3
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/airtable/callback` or your custom callback URL
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Airtable OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/airtable/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Airtable OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Airtable,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Airtable OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.AIRTABLE,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Airtable OAuth Documentation](https://airtable.com/developers/web/guides/oauth-integrations)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up Asana OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/asana
Complete guide to creating and configuring a Asana OAuth application
## Prerequisites
* Asana account (personal or business)
* Access to Asana Developer Portal
## Step 1: Create Asana Developer Account
1. Visit [https://asana.com/developers/](https://asana.com/developers)
2. Click **"Get started"** or **"Login"** if you already have an account
3. Sign in with your Asana account or create a new developer account
## Step 2: Create a New App
1. Once logged in, go to your settings -> **Apps**, and click **"Build new apps"**
2. Click **"Create new app"** under **"My apps"** section
3. Fill in the app details:
* **App name**: Your application name (e.g., your brand name)
* **Which best describes what your app will do?**: (Choose your preference)
* **Asana API Terms**: Agree to the terms and conditions
## Step 3: Configure OAuth Settings
1. After creating the app, you'll see:
* **Client ID**: Copy this value
* **Client Secret**: Copy this value (keep it secure!)
2. **Redirect URIs**: Add your callback URL:
* `https://api.klavis.ai/oauth/asana/callback`
## Step 4: Request Scopes
Klavis Asana MCP Server uses the following OAuth scopes: `goals:read,project_templates:read,projects:read,projects:write,projects:delete,stories:read,task_templates:read,tasks:read,tasks:write,tasks:delete,teams:read,users:read,workspaces:read,workspaces.typeahead:read`
1. Scroll to **"Permission scopes"** tab from **"Oauth"** menu
2. **Scopes**: Select the scopes your application needs:
You have successfully created an Asana OAuth application! You now have your Client ID, Client Secret, and Redirect Url ready for integration with Klavis AI.
## (Optional) Step 5: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Asana OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Asana **Client ID** and **Client Secret** from Step 3
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/asana/callback` or your custom callback URL
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Asana OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/asana/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Asana OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Asana,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Asana OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.ASANA,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Asana OAuth Documentation](https://developers.asana.com/docs/oauth)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up Calendly OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/calendly
Complete guide to creating and configuring a Calendly OAuth application
## Prerequisites
* Calendly account (personal or business)
* Access to Calendly Developer Portal
## Step 1: Create Calendly Developer Account
1. Visit [https://developer.calendly.com/](https://developer.calendly.com/)
2. Click **"Sign In"** or **"Log In"** if you already have an account
3. Sign in with your Calendly account or create a new developer account
## Step 2: Create a New App
1. Once logged in, go to **"Accounts"** -> **"My Apps"**
2. Click **"Create a new app"**
3. Choose **"Web App"** as the integration type
4. Fill in the app details:
* **Name of app**: Your application name (e.g., your brand name)
* **Kind of app**: Web/Native (depending on your need)
* **Environment Type**: Sandbox/Production (**Production** recommended)
* **Redirect URIs**: Add your callback URL:
* `https://api.klavis.ai/oauth/calendly/callback`
Normally, the redirect URI should be set to: `https://api.klavis.ai/oauth/calendly/callback`
## Step 3: Get Your Credentials
After creating the app, you'll see:
* **Client ID**: Copy this value
* **Client Secret**: Generate and copy this value (keep it secure!)
Calendly does not use traditional OAuth scopes. Once authenticated, your application has access to all API endpoints permitted by the user's subscription and role.
## (Optional) Step 4: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Calendly OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Calendly **Client ID** and **Client Secret** from Step 3
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/calendly/callback` or your custom callback URL
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Calendly OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/calendly/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Calendly OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Calendly,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Calendly OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.CALENDLY,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Calendly Developer Documentation](https://developer.calendly.com/getting-started)
* [Calendly OAuth 2.0 Authentication Guide](https://developer.calendly.com/create-a-developer-account)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
* [Calendly API Reference](https://developer.calendly.com/getting-started#access-requirements)
# Setting Up Canva OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/canva
Complete guide to creating and configuring a Canva OAuth application
## Prerequisites
* Canva account
* Multi-Factor Authentication (MFA) enabled on your Canva account
Make sure your account has a password. Set it up by going to Settings > Login > Password.
**Without password configured:**
**With password configured (showing MFA option):**
## Step 1: Create Canva Developer Account & Integration
1. Visit [https://developer.canva.com/](https://developer.canva.com/) and sign in with your Canva credentials
2. Navigate to **"Your integrations"** page
3. Click **"Create an integration"** and fill out the form:
* **Integration type**: Choose between "Public" (available to all users after review) or "Private" (team only)
* **Integration name**: Choose a descriptive name
* Accept Canva's Developer Terms
## Step 2: Configure Integration Settings
1. Under **"Configuration"** ā **"Configure your integration"**, set the following:
* **Integration name**: Add your application name
* **Client ID**: Make note of this value for later use
* **Generate secret**: Click to generate and securely save your Client Secret
## Step 3: Set Required Scopes
Klavis Canva MCP Server uses the following OAuth scopes: `app:read app:write asset:read asset:write brandtemplate:content:read brandtemplate:meta:read comment:read comment:write design:content:read design:content:write design:meta:read design:permission:read design:permission:write folder:read folder:write folder:permission:read folder:permission:write profile:read`
1. Under **"Scopes"** ā **"Set the scopes"**, configure the required permissions as shown in the screenshot below:
## Step 4: Configure Authentication & Redirect URLs
1. Under **"Authentication"** ā **"Add Authentication"**, add redirect URL:
* `https://api.klavis.ai/oauth/canva/callback`
## Step 5: Submit for Review (Public Integrations Only)
If you created a "Private" integration, you can skip this step. Private integrations are immediately available to your team.
For public integrations:
1. Complete all required configuration sections
2. Click **"Submit for Review"**
3. Wait for Canva's approval process
## Step 6: Integration Review Status
Once submitted, your integration will show "In Review" status. You'll receive email notifications about the review progress, and you will be asked to complete a questionnaire in the Jira ticket from the email.
You have successfully created a Canva OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
## (Optional) Step 7: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Canva OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Canva **Client ID** and **Client Secret** from Step 2
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/canva/callback` or your custom callback URL
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Canva OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/canva/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Canva OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Canva,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Canva OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.CANVA,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Canva Connect API Documentation](https://www.canva.dev/docs/connect/)
* [Canva OAuth 2.0 Authentication Guide](https://www.canva.dev/docs/connect/authentication/)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
* [Canva Setting up Multi-Factor Authentication](https://www.canva.com/help/login-verification/)
# Setting Up Discord OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/discord
Complete guide to creating and configuring a Discord OAuth application
## Prerequisites
* Discord account
* Access to Discord Developer Portal
## Step 1: Create Discord Developer Account
1. Visit [https://discord.com/developers](https://discord.com/developers)
2. Click **"Get Started"** or **"Login"** if you already have an account
3. Sign in with your Discord account or create a new developer account
## Step 2: Create a New App
1. Once logged in, go to **"Applications"** in your developer dashboard
2. Click **"New Application"** to create a new app
3. Click on the **"App"** that you just created
4. Go to **"General Information"** section
5. Fill in the app details:
* **App name**: Your application name (e.g., your brand name)
* **App description**: Your application description
* **"App Icon"**: Upload 100x100px PNG (recommended)
* **"Tags"**: Add tags that describe your application
* **Privacy policy URL**: Your privacy policy URL
* **Terms of service URL**: Your terms of service URL
## Step 3: Build A Bot
1. Go to **"Bot"** section.
2. Get **Discord Token**:
* Click on **Reset Token** button under **TOKEN** tab
* Enter your **Discord Password** and press **Submit**
* New **Token** has been generated
* **Copy** this token (keep it secure!)
3. Set **Bot Permissions**:
* Choose **Administrator** under **General Permissions** (recommended)
Klavis AI recommends to select required OAuth scopes only.
## Step 4: Configure OAuth Settings
Navigate to **"OAuth2"**:
* **Client ID**: Copy this value
* **Client Secret**: Generate and copy this value (keep it secure!)
* **Redirect URI**: Set as **[https://api.klavis.ai/oauth/discord/callback](https://api.klavis.ai/oauth/discord/callback)**
Normally, the redirect URI should be set to: `https://api.klavis.ai/oauth/discord/callback`
## Step 5: OAuth2 URL Generator
1. Scroll to **Scopes**
* Select **bot** from the scopes list
* For **Bot Permissions**: select **Administrator**
2. Generate URL:
* Integration Type: **Guild Install** (recommended)
* Copy **Generated URL** and paste in browser to complete authentication
You have successfully created a Discord OAuth application! You now have your Client ID and Client Secret, and Discord Token ready for integration with Klavis AI.
## (Optional) Step 6: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Discord OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Discord **Client ID** and **Client Secret** from Step 4
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/discord/callback` or your custom callback URL
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Discord OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/discord/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Discord OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Discord,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Discord OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.Discord,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Discord Developer Documentation](https://discord.com/developers/docs/intro/)
* [Discord OAuth 2.0 Authentication Guide](https://discord.com/developers/docs/topics/oauth2)
* [Discord API Scopes Reference](https://discord.com/developers/docs/topics/oauth2#shared-resources-oauth2-scopes)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up Dropbox OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/dropbox
Complete guide to creating and configuring a Dropbox OAuth application
## Prerequisites
* Dropbox account (personal or business)
* Access to Dropbox Developer Console
## Step 1: Create Dropbox Developer Account & App
1. Visit [https://www.dropbox.com/developers](https://www.dropbox.com/developers) and sign in with your Dropbox credentials
2. Click **"Create apps"** and fill out the form:
* **Choose an API**: Select **"Scoped access"**
* **Choose the type of access**: Select **"Full Dropbox"** for complete access or **"App folder"** for restricted access
* **Name your app**: Choose a descriptive name for your application
* **Choose the Dropbox account**: Select your personal or business account
## Step 2: Configure OAuth Settings
1. After creating the app, you'll be redirected to the app settings page
2. In **"OAuth 2"** section, add redirect URLs:
* `https://api.klavis.ai/oauth/dropbox/callback`
3. Note your **App key** and **App secret**
## Step 3: Set Required Permissions
Klavis Dropbox MCP Server uses the following OAuth scopes: `account_info.read files.metadata.read files.metadata.write files.content.read files.content.write file_requests.read file_requests.write sharing.read sharing.write contacts.read contacts.write`
1. Go to the **"Permissions"** tab and configure the required permissions as shown in the screenshot below:
2. Click **"Submit"** to save your permission settings
You have successfully created a Dropbox OAuth application! You now have your App Key and App Secret ready for integration with Klavis AI.
**Klavis handles all token management automatically** - we securely store and manage your tokens so you maintain seamless access to your Dropbox data without any interruption.
## (Local Testing) Step 4: Generate Access Token
1. In the **"Settings"** tab, scroll to the **"OAuth 2"** section
2. Click **"Generate"** under **"Generated access token"**
3. Copy and securely store the generated token
## (Optional) Step 5: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Dropbox OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Dropbox **App Key** and **App Secret** from Step 2
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/dropbox/callback` or your custom callback URL
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Dropbox OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/dropbox/authorize?instance_id=${instanceId}&client_id=${yourAppKey}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Dropbox OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Dropbox,
instanceId: instanceId,
clientId: yourAppKey,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Dropbox OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.DROPBOX,
instance_id=instance_id,
client_id=your_app_key,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Dropbox OAuth Guide](https://developers.dropbox.com/oauth-guide)
* [Dropbox OAuth 2.0 Documentation](https://www.dropbox.com/developers/http/documentation#oauth2-authorize)
* [Dropbox Developer Apps Console](https://www.dropbox.com/developers/apps)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up Figma OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/figma
Complete guide to creating and configuring a Figma OAuth application
## Prerequisites
* Figma account (personal or business)
* Access to Figma Developer Portal
## Step 1: Create Figma Developer Account
1. Visit [https://www.figma.com/developers/](https://www.figma.com/developers/)
2. Click **"Sign Up"** or **"Login"** if you already have an account
3. Sign in with your Figma account or create a new developer account
## Step 2: Create a New App
1. Once logged in, go to your developer dashboard -> **"My Apps"**
2. Click **"Create a new app"**
3. Fill in the app details:
* **App name**: Your application name (e.g., your brand name)
* **Website**: Your company website
* **App logo**: Upload 100x100px PNG (recommended)
## Step 3: Get Your Credentials
Klavis Figma MCP Server uses the following OAuth scopes: `files:read,file_comments:write,openid,email,profile`
After creating the app, navigate to **OAuth 2.0** tab
* **Client ID**: Copy this value
* **Client Secret**: Generate and copy this value (keep it secure!)
* **Redirect URIs**: Add your callback URL:
* `https://api.klavis.ai/oauth/figma/callback`
You have successfully created a Figma OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
## (Optional) Step 4: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Figma OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Figma **Client ID** and **Client Secret** from Step 3
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/figma/callback` or your custom callback URL
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Figma OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/figma/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Figma OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Figma,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Figma OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.FIGMA,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Figma Developer Documentation](https://www.figma.com/developers/api)
* [Figma OAuth 2.0 Authentication Guide](https://www.figma.com/developers/api#authentication)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
* [Figma API Scopes Reference](https://www.figma.com/developers/api#authentication-scopes)
# Setting Up Gmail OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/gmail
Complete guide to creating and configuring a Gmail OAuth application
## Prerequisites
* Google account
## Step 1: Create a Project
1. Visit [https://console.cloud.google.com/home/dashboard](https://console.cloud.google.com/home/dashboard) and select the project dropdown at the top.
2. Click **New Project**.
3. Enter the project details and click **Create**.
4. Select your newly created project.
5. Go to **APIs & Services**.
6. Click **Enable APIs and Services**.
7. Search for and select **Gmail API**.
8. Click **Enable**.
9. Go back to **APIs & Services** and select **OAuth consent screen**.
10. Enter the required information and save.
11. Go to **Credentials** in APIs & Services and click **Create Credentials**.
12. Select **OAuth Client ID**.
13. Choose **Web Application** and enter the required details.
14. Add redirect URLs:
`https://api.klavis.ai/oauth/gmail/`
Then click **Create**.
15. Your **Client ID** and **Client Secret** will be displayed.
## Step 2: Request Scopes
Klavis Gmail MCP Server uses the following OAuth scopes:
`https://www.googleapis.com/auth/gmail.readonly`
`https://www.googleapis.com/auth/gmail.send`
`https://www.googleapis.com/auth/gmail.compose`
`https://www.googleapis.com/auth/gmail.modify`
1. Go to **OAuth consent screen**.
2. Click **Data Access**.
3. Click **Add or Remove Scopes**.
4. Enter the needed scopes and click **Update**.
You have successfully created a Gmail OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
## (Optional) Step 3: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Gmail OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Gmail **Client ID** and **Client Secret** from Step 1.
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/gmail/callback` or your custom callback URL.
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Gmail OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/gmail/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Gmail OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Gmail,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Gmail OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.GMAIL,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up Google Calendar OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/google_calendar
Complete guide to creating and configuring a Google Calendar OAuth application
## Prerequisites
* Google account
## Step 1: Create a Project
1. Visit [https://console.cloud.google.com/home/dashboard](https://console.cloud.google.com/home/dashboard) and select the project dropdown at the top.
2. Click **New Project**.
3. Enter the project details and click **Create**.
4. Select your newly created project.
5. Go to **APIs & Services**.
6. Click **Enable APIs and Services**.
7. Search for and select **Google Calendar API**.
8. Click **Enable**.
9. Go back to **APIs & Services** and select **OAuth consent screen**.
10. Enter the required information and save.
11. Go to **Credentials** in APIs & Services and click **Create Credentials**.
12. Select **OAuth Client ID**.
13. Choose **Web Application** and enter the required details.
14. Add redirect URLs:
`https://api.klavis.ai/oauth/gcalendar/callback`
Then click **Create**.
15. Your **Client ID** and **Client Secret** will be displayed.
## Step 2: Request Scopes
Klavis Google Calendar MCP Server uses the following OAuth scopes:
`https://www.googleapis.com/auth/calendar.readonly`
`https://www.googleapis.com/auth/calendar.events`
1. Go to **OAuth consent screen**.
2. Click **Data Access**.
3. Click **Add or Remove Scopes**.
4. Enter the needed scopes and click **Update**.
You have successfully created a Google Calendar OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
## (Optional) Step 3: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Google Calendar OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Google Calendar **Client ID** and **Client Secret** from Step 1.
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/gcalendar/callback` or your custom callback URL.
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Google Calendar OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/gcalendar/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Google Calendar OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Gcalendar,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Google Calendar OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.GCALENDAR,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up Google Docs OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/google_docs
Complete guide to creating and configuring a Google Docs OAuth application
## Prerequisites
* Google account
## Step 1: Create a Project
1. Visit [https://console.cloud.google.com/home/dashboard](https://console.cloud.google.com/home/dashboard) and select the project dropdown at the top.
2. Click **New Project**.
3. Enter the project details and click **Create**.
4. Select your newly created project.
5. Go to **APIs & Services**.
6. Click **Enable APIs and Services**.
7. Search for and select **Google Docs API**.
8. Click **Enable**.
9. Go back to **APIs & Services** and select **OAuth consent screen**.
10. Enter the required information and save.
11. Go to **Credentials** in APIs & Services and click **Create Credentials**.
12. Select **OAuth Client ID**.
13. Choose **Web Application** and enter the required details.
14. Add redirect URLs:
`https://api.klavis.ai/oauth/gdocs/callback`
Then click **Create**.
15. Your **Client ID** and **Client Secret** will be displayed.
## Step 2: Request Scopes
Klavis Google Docs MCP Server uses the following OAuth scopes:
`https://www.googleapis.com/auth/drive`
1. Go to **OAuth consent screen**.
2. Click **Data Access**.
3. Click **Add or Remove Scopes**.
4. Enter the needed scopes and click **Update**.
You have successfully created a Google Docs OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
## (Optional) Step 3: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Google Docs OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Google Docs **Client ID** and **Client Secret** from Step 1.
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/gdocs/callback` or your custom callback URL.
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Google Docs OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/gdocs/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Google Docs OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Gdocs,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Google Docs OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.GDOCS,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up Google Drive OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/google_drive
Complete guide to creating and configuring a Google Drive OAuth application
## Prerequisites
* Google account
## Step 1: Create a Project
1. Visit [https://console.cloud.google.com/home/dashboard](https://console.cloud.google.com/home/dashboard) and select the project dropdown at the top.
2. Click **New Project**.
3. Enter the project details and click **Create**.
4. Select your newly created project.
5. Go to **APIs & Services**.
6. Click **Enable APIs and Services**.
7. Search for and select **Google Drive API**.
8. Click **Enable**.
9. Go back to **APIs & Services** and select **OAuth consent screen**.
10. Enter the required information and save.
11. Go to **Credentials** in APIs & Services and click **Create Credentials**.
12. Select **OAuth Client ID**.
13. Choose **Web Application** and enter the required details.
14. Add redirect URLs:
`https://api.klavis.ai/oauth/gdrive/callback`
Then click **Create**.
15. Your **Client ID** and **Client Secret** will be displayed.
## Step 2: Request Scopes
Klavis Google Drive MCP Server uses the following OAuth scopes:
`https://www.googleapis.com/auth/drive`
1. Go to **OAuth consent screen**.
2. Click **Data Access**.
3. Click **Add or Remove Scopes**.
4. Enter the needed scopes and click **Update**.
You have successfully created a Google Drive OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
## (Optional) Step 3: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Google Drive OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Google Drive **Client ID** and **Client Secret** from Step 1.
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/gdrive/callback` or your custom callback URL.
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Google Drive OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/gdrive/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Google Drive OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Gdrive,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Google Drive OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.GDRIVE,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up Google Sheets OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/google_sheets
Complete guide to creating and configuring a Google Sheets OAuth application
## Prerequisites
* Google account
## Step 1: Create a Project
1. Visit [https://console.cloud.google.com/home/dashboard](https://console.cloud.google.com/home/dashboard) and select the project dropdown at the top.
2. Click **New Project**.
3. Enter the project details and click **Create**.
4. Select your newly created project.
5. Go to **APIs & Services**.
6. Click **Enable APIs and Services**.
7. Search for and select **Google Sheets API**.
8. Click **Enable**.
9. Go back to **APIs & Services** and select **OAuth consent screen**.
10. Enter the required information and save.
11. Go to **Credentials** in APIs & Services and click **Create Credentials**.
12. Select **OAuth Client ID**.
13. Choose **Web Application** and enter the required details.
14. Add redirect URLs:
`https://api.klavis.ai/oauth/gsheets/callback`
Then click **Create**.
15. Your **Client ID** and **Client Secret** will be displayed.
## Step 2: Request Scopes
Klavis Google Sheets MCP Server uses the following OAuth scopes:
`https://www.googleapis.com/auth/drive`
1. Go to **OAuth consent screen**.
2. Click **Data Access**.
3. Click **Add or Remove Scopes**.
4. Enter the needed scopes and click **Update**.
You have successfully created a Google Sheets OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
## (Optional) Step 3: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Google Sheets OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Google Sheets **Client ID** and **Client Secret** from Step 1.
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/gsheets/callback` or your custom callback URL.
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Google Sheets OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/gsheets/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Google Sheets OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Gsheets,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Google Sheets OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.GSHEETS,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up HubSpot OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/hubspot
Complete guide to creating and configuring a HubSpot OAuth application
## Prerequisites
* HubSpot developers account
## Step 1: Create HubSpot Developer Account & App
1. Visit [https://developers.hubspot.com/](https://developers.hubspot.com/) and sign in
2. Click **"Create App"** and fill out the form:
* **Public app name**: Choose a descriptive name
* **App logo**: Upload 100x100px PNG (recommended)
* **Description**: Associate with your company
## Step 2: Configure OAuth Settings
1. Go to the **"Auth"** tab in your application dashboard
2. Add redirect URLs: `https://api.klavis.ai/oauth/hubspot/callback`
Here is an example of Klavis AI OAuth app configuration:
## Step 3: Request Scopes
Klavis Hubspot MCP Server uses the following OAuth scopes: `account-info.security.read, accounting, cms.domains.read, cms.domains.write, crm.export, crm.import, crm.lists.read, crm.lists.write, crm.objects.companies.read, crm.objects.companies.write, crm.objects.contacts.read, crm.objects.contacts.write, crm.objects.deals.read, crm.objects.deals.write, crm.objects.marketing_events.read, crm.objects.marketing_events.write, crm.objects.owners.read, crm.objects.quotes.read, crm.objects.quotes.write, crm.schemas.companies.read, crm.schemas.companies.write, crm.schemas.contacts.read, crm.schemas.contacts.write, oauth, settings.users.read, settings.users.write, tickets, timeline, e-commerce, crm.objects.custom.read, crm.schemas.custom.read, content, sales-email-read`
1. Go to the **"Auth"** tab in your application dashboard
2. Scroll down to **"Scopes"**.
3. Click **"Add New Scope"** and add required scopes.
Here is an example of Klavis AI OAuth app configuration:
## Step 4: Create App
1. Now Click the **"Create App"** Button
You have successfully created a HubSpot OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
## (Optional) Step 5: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own HubSpot OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your HubSpot **Client ID** and **Client Secret**
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/hubspot/callback` or your custom callback URL
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating HubSpot OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/hubspot/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating HubSpot OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Hubspot,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating HubSpot OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.HUBSPOT,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [HubSpot OAuth Documentation](https://developers.hubspot.com/docs/guides/apps/authentication/working-with-oauth)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up LinkedIn OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/linkedin
Complete guide to creating and configuring a LinkedIn OAuth application
## Prerequisites
* LinkedIn personal account
* LinkedIn company page (required for app creation with admin access)
## Step 1: Create LinkedIn Developer Account & App
1. Visit [https://developer.linkedin.com/](https://developer.linkedin.com/) and sign in
2. Click **"Create App"** and fill out the form:
* **App name**: Choose a descriptive name
* **LinkedIn Page**: Associate with your company page
* **App logo**: Upload 100x100px PNG (recommended)
* Accept LinkedIn's API Terms of Use
## Step 2: Configure OAuth Settings
1. Go to the **"Auth"** tab in your application dashboard
2. Add redirect URLs: `https://api.klavis.ai/oauth/linkedin/callback`
Here is an example of Klavis AI OAuth app configuration:
## Step 3: Request Scopes
Klavis LinkedIn MCP Server uses the following OAuth scopes: `openid,profile,email,w_member_social`
1. Go to **"Products"** tab and request **"Shared on LinkedIn"** and **"Sign In with LinkedIn using OpenID Connect"**
2. Once approved, you can see **Client ID** and **Client Secret** from the **"Auth"** tab
Here is an example of Klavis AI OAuth app configuration:
You have successfully created a LinkedIn OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
## (Optional) Step 4: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own LinkedIn OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your LinkedIn **Client ID** and **Client Secret** from Step 3
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/linkedin/callback` or your custom callback URL
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating LinkedIn OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/linkedin/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating LinkedIn OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Linkedin,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating LinkedIn OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.LINKEDIN,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [LinkedIn OAuth Documentation](https://docs.microsoft.com/en-us/linkedin/shared/authentication/authorization-code-flow)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up Monday.com OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/monday
Complete guide to creating and configuring a Monday.com OAuth application
## Prerequisites
* Monday.com account (admin access recommended)
## Step 1: Create a Monday App & Get Credentials
1. Log in to [Monday.com](https://monday.com)
2. Click your **avatar (top-right)** ā **Developers**
3. In the Developer Console, click **Create App**
4. Once the app is created, you can immediately see the **Client ID** and **Client Secret**
5. Copy both and keep them safe
You now have your Monday.com **Client ID** and **Client Secret** ready for integration with Klavis AI.
## Step 2: Configure OAuth & Permissions
Klavis Monday MCP Server typically uses:
`users:read, boards:read, boards:write, updates:write`
1. Open your app ā go to **OAuth & Permissions**
2. Under **Scopes**, select the permissions your app requires.
3. Under **Redirect URLs**, add:
```
https://api.klavis.ai/oauth/monday/callback
```
## Step 3: Promote to Live
1. Once everything is set up, click **Promote to Live**.
Your app will now have permanent credentials and can be used in production
You have successfully created Monday.com OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
## (Optional) Step 4: White Labeling
White labeling lets you use your own Monday.com OAuth app branding instead of Klavis AIās default.
To use your own OAuth app:
1. Go to [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
2. Enter your **Monday Client ID** and **Client Secret** from Step 1
3. Confirm the redirect URI:
```
https://api.klavis.ai/oauth/monday/callback
```
4. Start the OAuth flow with your client ID:
```javascript theme={null}
const authUrl = `https://api.klavis.ai/oauth/monday/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
```
For detailed examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Monday.com Docs](https://developer.monday.com/apps)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up Moneybird OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/moneybird
Complete guide to creating and configuring a Moneybird OAuth application
## Prerequisites
* Moneybird Account
## Step 1: Registration of your application
1. Visit [https://moneybird.com/user/applications/new](https://moneybird.com/user/applications/new)
2. Enter a Good Name
3. Add callback URL: `https://api.klavis.ai/oauth/moneybird/callback`
4. Click Save.
From This, You will Get Your Client ID and Client secret.
## Step 2: Request Scopes
Klavis Moneybird MCP Server uses the following OAuth scopes: `sales_invoices, documents, estimates, bank, time_entries, settings`
When redirecting a user to the Moneybird authorization page, include the scope parameter in your URL. Multiple scopes should be space-separated.
Example authorization URL:
```
curl -vv \
'https://moneybird.com/oauth/authorize?client_id=9a833de2d13b07dfdfb50a8124b148d8&redirect_uri=urn:ietf:wg:oauth:2.0:oob&response_type=code&scope=extimates%20bank'
```
You have successfully created a Moneybird OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
## (Optional) Step 3: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Moneybird OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Moneybird **Client ID** and **Client Secret** from Step 1
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/moneybird/callback` or your custom callback URL
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Moneybird OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/moneybird/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Moneybird OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Moneybird,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Moneybird OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.MONEYBIRD,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Moneybird OAuth Documentation](https://developer.moneybird.com/authentication/)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# OAuth Scopes Reference
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/oauth-scopes
## Overview
This page provides a comprehensive reference of OAuth scopes required for each supported app in Klavis AI.
These are the minimum OAuth scopes required for all tools in each Klavis MCP server to function properly.
## Supported OAuth App
```
data.records:read
data.records:write
data.recordComments:read
data.recordComments:write
schema.bases:read
schema.bases:write
user.email:read
```
```
goals:read
project_templates:read
projects:read
projects:write
projects:delete
stories:read
task_templates:read
tasks:read
tasks:write
tasks:delete
teams:read
users:read
workspaces:read
workspaces.typeahead:read
```
Attio uses API key authentication rather than OAuth scopes. No specific scopes are required for this integration.
```
app:read
app:write
asset:read
asset:write
brandtemplate:content:read
brandtemplate:meta:read
comment:read
comment:write
design:content:read
design:content:write
design:meta:read
design:permission:read
design:permission:write
folder:read
folder:write
folder:permission:read
folder:permission:write
profile:read
```
ClickUp uses OAuth 2.0 with client credentials. The specific scopes are managed through the ClickUp app configuration rather than explicit scope parameters.
```
all.full_access
offline_access
```
```
write:space.permission:confluence
write:space:confluence
read:attachment:confluence
read:page:confluence
write:page:confluence
search:confluence
read:space:confluence
read:hierarchical-content:confluence
write:confluence-content
read:confluence-content.all
read:confluence-content.summary
read:confluence-space.summary
write:confluence-space
write:confluence-file
read:confluence-props
write:confluence-props
manage:confluence-configuration
read:confluence-content.permission
read:confluence-user
read:confluence-groups
write:confluence-groups
readonly:content.attachment:confluence
read:me
read:account
report:personal-data
offline_access
```
```
account_info.read
files.metadata.read
files.metadata.write
files.content.read
files.content.write
file_requests.read
file_requests.write
sharing.read
sharing.write
contacts.read
contacts.write
```
```
repo
read:user
read:org
security_events
```
```
https://www.googleapis.com/auth/gmail.readonly
https://www.googleapis.com/auth/gmail.send
https://www.googleapis.com/auth/gmail.compose
https://www.googleapis.com/auth/gmail.modify
```
```
https://www.googleapis.com/auth/calendar.readonly
https://www.googleapis.com/auth/calendar.events
```
```
https://www.googleapis.com/auth/drive
```
```
https://www.googleapis.com/auth/drive
```
```
https://www.googleapis.com/auth/drive
```
```
account-info.security.read
accounting
cms.domains.read
cms.domains.write
crm.export
crm.import
crm.lists.read
crm.lists.write
crm.objects.companies.read
crm.objects.companies.write
crm.objects.contacts.read
crm.objects.contacts.write
crm.objects.deals.read
crm.objects.deals.write
crm.objects.marketing_events.read
crm.objects.marketing_events.write
crm.objects.owners.read
crm.objects.quotes.read
crm.objects.quotes.write
crm.schemas.companies.read
crm.schemas.companies.write
crm.schemas.contacts.read
crm.schemas.contacts.write
oauth
settings.users.read
settings.users.write
tickets
timeline
e-commerce
crm.objects.custom.read
crm.schemas.custom.read
content
sales-email-read
```
```
read:jira-user
read:jira-work
write:jira-work
manage:jira-configuration
offline_access
```
```
read
write
issues:create
comments:create
timeSchedule:write
```
```
openid
profile
email
w_member_social
```
```
users:read
boards:read
boards:write
updates:write
```
```
sales_invoices
documents
estimates
bank
time_entries
settings
```
```
read_content
update_content
insert_content
read_comments
insert_comments
read_user_information_including_email_addresses
```
```
openid
profile
email
offline_access
Files.ReadWrite.All
User.Read
```
```
com.intuit.quickbooks.accounting
com.intuit.quickbooks.payment
openid
```
```
api
refresh_token
offline_access
```
**Bot Scopes:**
```
app_mentions:read
channels:history
channels:read
chat:write
chat:write.customize
commands
files:read
groups:read
groups:write
im:history
im:read
mpim:read
reactions:read
reactions:write
team:read
users:read
```
**User Scopes:**
```
channels:history
channels:read
channels:write
chat:write
groups:history
groups:read
groups:write
im:history
im:read
im:write
mpim:history
mpim:read
users:read
users:write
search:read
```
Supabase uses OAuth 2.0 with client credentials. The specific scopes are managed through the Supabase project configuration rather than explicit scope parameters.
```
global
```
```
accounting.transactions.read
accounting.transactions
offline_access
```
## Need Help?
If you need assistance with OAuth scope configuration for any specific application, please refer to the individual OAuth app setup guides or contact our support team.
# Setting Up OneDrive OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/onedrive
Complete guide to creating and configuring a OneDrive OAuth application
## Prerequisites
* Microsoft account (personal or organizational)
* Access to [Azure Portal](https://portal.azure.com/)
## Step 1: Create Microsoft App Registration
1. Visit [https://portal.azure.com/](https://portal.azure.com/) and sign in
2. Search **App registrations** ā click **New registration**
3. Fill out the form:
* **Name**: Choose a descriptive app name
* **Supported account types**: Select **Accounts in any organizational directory and personal Microsoft accounts**
* **Redirect URI**: `https://api.klavis.ai/oauth/onedrive/callback`
4. Click **Register**
## Step 2: Configure API Permissions
Klavis OneDrive MCP Server uses the following OAuth scopes:`openid, profile, email, offline_access, Files.ReadWrite.All, User.Read`
1. Go to your app ā **API Permissions**
2. Click **Add a permission** ā **Microsoft Graph** ā **Delegated permissions**
3. Select:
* `openid`, `profile`, `email`, `offline_access`
* `Files.ReadWrite.All`
* `User.Read`
4. Click **Add permissions**
5. (Optional) Click **Grant admin consent** if you want to approve for all org users
## Step 3: Collect Client ID & Secret
1. Go to **Certificates & Secrets** tab
2. Click **New client secret** ā set description + expiry ā **Add**
3. Copy the **Client Secret Value** (shown only once)
4. From **Overview** tab, copy **Application (client) ID**
You have successfully created a OneDrive OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
## (Optional) Step 4: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own OneDrive OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your OneDrive **Client ID** and **Client Secret** from Step 3
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/onedrive/callback` or your custom callback URL
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating OneDrive OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/onedrive/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating OneDrive OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Onedrive,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating OneDrive OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.ONEDRIVE,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Microsoft Identity Platform Docs](https://learn.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-auth-code-flow)
* [Microsoft Graph API ā OneDrive](https://learn.microsoft.com/en-us/graph/onedrive-concept-overview)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up QuickBooks OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/quickbooks
Complete guide to creating and configuring a QuickBooks OAuth application
## Prerequisites
* Intuit Developer account (free to sign up)
* Access to Intuit Developer Platform
## Step 1: Create Intuit Developer Account & Workspace
1. Visit [https://developer.intuit.com](https://developer.intuit.com) and sign in with your Intuit credentials
2. Click **"Create a workspace"** to set up your development environment
3. Fill out the workspace creation form with three steps:
* **Step 1 - Basic Information**: Enter workspace name and description
* **Step 2 - Company Information**: Provide your company details
* **Step 3 - Contact Information**: Add your contact information
4. Click **"Create workspace"** to complete the setup
## Step 2: Create QuickBooks OAuth Application
1. After workspace creation, click **"Create an app"** to start building your QuickBooks integration
2. In the app creation dialog, select app type and configure basic information:
* **Choose "QuickBooks Online"** as your app type
* **Enter your app name** (avoid using "Intuit" or "QuickBooks" in the name)
* **Provide app description**
## Step 3: Configure OAuth Permissions
Klavis QuickBooks MCP Server uses the following OAuth scopes: `com.intuit.quickbooks.accounting` (for full accounting data access) and `com.intuit.quickbooks.payment` (for payment processing)
1. In the permissions configuration step, select the required QuickBooks scopes:
* **com.intuit.quickbooks.accounting** - For accessing accounting data (customers, invoices, items, etc.)
* **com.intuit.quickbooks.payment** - For payment processing capabilities
2. Review and confirm the permissions by clicking **"Confirm"**
## Step 4: Access Your OAuth Credentials
1. Once your app is created, you'll see the success page with your development credentials
2. Navigate to **"Keys and credentials"** in the left sidebar to view your OAuth credentials:
* **Client ID**: Your OAuth application identifier
* **Client Secret**: Your OAuth application secret (keep this secure)
3. Configure your redirect URIs:
* For Klavis integration: `https://api.klavis.ai/oauth/quickbooks/callback`
* For local development: `http://localhost:3000/oauth/quickbooks/callback`
You have successfully created a QuickBooks OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
**Klavis handles all token management automatically** - we securely store and manage your OAuth tokens so you maintain seamless access to your QuickBooks data without any interruption.
## (Local Testing) Step 5: Testing Your Integration
1. Open the Intuit API Playground: [https://developer.intuit.com/app/developer/playground](https://developer.intuit.com/app/developer/playground)
2. Select your app and environment (Development)
3. Click "Get Access Token" to authorize and retrieve the token
4. Copy both the Access Token and the Realm ID for testing API calls
Use the Access Token as the Bearer token in Authorization header and the Realm ID as the companyId for API requests.
## (Optional) Step 6: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own QuickBooks OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your QuickBooks **Client ID** and **Client Secret** from Step 4
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/quickbooks/callback` or your custom callback URL
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating QuickBooks OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/quickbooks/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating QuickBooks OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Quickbooks,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating QuickBooks OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.QUICKBOOKS,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [QuickBooks Online API Documentation](https://developer.intuit.com/app/developer/qbo/docs/api/accounting/all-entities/account)
* [QuickBooks OAuth 2.0 Guide](https://developer.intuit.com/app/developer/qbo/docs/develop/authentication-and-authorization/oauth_2.0)
* [Intuit Developer Platform](https://developer.intuit.com)
* [QuickBooks API Explorer](https://developer.intuit.com/app/developer/qbo/docs/api/accounting/all-entities/account)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up Salesforce OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/salesforce
Complete guide to creating and configuring a Salesforce OAuth application
## Prerequisites
* Salesforce account (personal or business)
* Access to Salesforce Developer Portal
## Step 1: Create Salesforce Developer Account
1. Visit [https://developer.salesforce.com/](https://developer.salesforce.com/)
2. Click **"Sign Up"** or **"Login"** if you already have an account
3. Sign in with your Salesforce account or create a new developer account
## Step 2: Enable Connected Apps
1. Once logged in, go to **"Setup Menu"** (Gear Icon) and click **"Setup"**
2. Search **"External Client Apps"** in the **"Quick Find"** search box
3. In **"External Client App Settings"**, enable **"Allow creation of connected apps"**
4. Click **"New Connected App"**
## Step 3: Fill Basic App Information
1. Fill the necessary app details:
* **Connected App Name**: Your application name (e.g., your brand name)
* **API Name**: Auto-generated from app name (only letters, numbers, and underscores allowed)
* **Contact Email**: Your contact email for Salesforce support
* **Contact Phone**: Your contact phone for Salesforce support
* **Logo Image URL**: (Optional) HTTPS URL for your app logo (max 100 KB, preferably under 20 KB)
* **Info URL**: (Optional) Web page with more information about your app
* **Description**: (Optional) Up to 256 characters describing your app
Klavis Salesforce MCP Server uses the following OAuth scopes: `api,refresh_token,offline_access`
1. In the **API (Enable OAuth Settings)** section:
* Select **"Enable OAuth Settings"**
* **Callback URL**: Enter `https://api.klavis.ai/oauth/salesforce/callback`
2. **Select OAuth Scopes**: Move required scopes from **"Available OAuth Scopes"** to **"Selected OAuth Scopes"**:
* `Manage User Data via APIs (api)` - required to manage user data via APIs
* `Perform requests on your behalf at any time (refresh_token, offline_access)` - required to perform requests at any time
3. **Additional Settings**:
* Enable **"Require Secret for Web Server Flow"** if your app can keep the client secret confidential
* Enable **"Require Secret for Refresh Token Flow"**
* Enable **"Enable Authorization Code and Credentials Flow"**
* Disable **"Require PKCE Extension for Supported Authorization Flows"**
4. Click **"Save"** to create the app
## Step 4: Get Consumer Key and Secret
After creating the app, follow these steps to get the credentials.
1. From dashboard, go to **"Setup Menu"** (Gear Icon) and click **"Setup"**
2. Search **"App Manager"** in the **"Quick Find"** search box
3. Find your connected app in the list and click the dropdown arrow, then select **"View"**
4. In the **API (Enable OAuth Settings)** section, click **"Manage Consumer Details"**
5. Verify your identity using the **verification code** sent to your email
6. Copy the **Consumer Key** and **Consumer Secret** (keep them secure!)
## (Optional) Step 5: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Salesforce OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Salesforce **Consumer Key** and **Consumer Secret** from Step 5
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/salesforce/callback` or your custom callback URL
4. **Initiate OAuth**: Use your Client Id when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Salesforce OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/salesforce/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Salesforce OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Salesforce,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Salesforce OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.SALESFORCE,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Salesforce Developer Documentation](https://developer.salesforce.com/docs)
* [Salesforce OAuth Authentication Guide](https://developer.salesforce.com/docs/atlas.en-us.api_streaming.meta/api_streaming/code_sample_auth_oauth.htm)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
* [Salesforce API Scopes Reference](https://developer.salesforce.com/docs/platform/mobile-sdk/guide/oauth-scope-parameter-values.html)
# Setting Up Slack OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/slack
Complete guide to creating and configuring a Slack OAuth application
## Prerequisites
* Slack Account
## Step 1: Create Slack Developer Account & App
1. Visit [https://api.slack.com/apps](https://api.slack.com/apps)
2. On the **Your Apps** page, select **Create New App**.
3. Select **From Scratch**.
4. Enter your **App Name**.
5. Select the **Workspace** where you'll be developing your app. You'll be able to distribute your app to other workspaces later if you choose.
6. Select **Create App**.
## Step 2: Configure OAuth Settings
1. Go to the **"OAuth & Permissions"** tab in your application dashboard
2. Add redirect URLs: `https://api.klavis.ai/oauth/slack/callback`
3. Click **"Save URLs"**
Here is an example of Klavis AI OAuth app configuration:
## Step 3: Request Scopes
Klavis Slack MCP Server uses the following OAuth scopes:
**Bot Scopes:** `app_mentions:read, channels:join, chat:write, im:history, reactions:read, reactions:write`
**User Scopes:** `channels:history, channels:read, channels:write.invites, chat:write, groups:history, groups:read, groups:write.invites, im:history, im:read, im:write, mpim:history, mpim:read, mpim:write, search:read, users:read`
1. Go to the **"OAuth & Permissions"** tab in your application dashboard.
2. Scroll Down to **"Scopes"**, and add scopes
You have successfully created a Slack OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
## Step 4: Configure App Distribution
1. Go to the **"Manage Distribution"** tab in your application dashboard
2. Configure your app's public distribution settings as needed
## (Optional) Step 5: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Slack OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Slack **Client ID** and **Client Secret**.
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/slack/callback` or your custom callback URL
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript theme={null}
const authUrl = `https://api.klavis.ai/oauth/slack/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Slack Quickstart](https://api.slack.com/quickstart)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
# Setting Up Xero OAuth App
Source: https://www.klavis.ai/docs/knowledge-base/oauth_app/xero
Complete guide to creating and configuring a Xero OAuth application
## Prerequisites
* Xero account (personal or business)
* Access to Xero Developer Portal
## Step 1: Create Xero Developer Account
1. Visit [https://developer.xero.com/](https://developer.xero.com/)
2. Click **"Get started for free"** or **"Login"** if you already have an account
3. Sign in with your Xero account or create a new developer account
## Step 2: Create a New App
1. Once logged in, go to your developer dashboard
2. Click **"New app"** or **"Create an app"**
3. Choose **"Web App"** as the integration type
4. Fill in the app details:
* **App name**: Your application name (e.g., your brand name)
* **Company or application URL**: Your company website
* **Privacy policy URL**: Your privacy policy URL
* **Terms of service URL**: Your terms of service URL
Normally, the redirect URI should be set to: `https://api.klavis.ai/oauth/xero/callback`
## Step 3: Configure OAuth Settings
Klavis Xero MCP Server uses the following OAuth scopes: `accounting.transactions.read accounting.transactions offline_access`
1. **Redirect URIs**: Add your callback URL:
* `https://api.klavis.ai/oauth/xero/callback`
2. **Scopes**: Select the scopes your application needs:
* `offline_access` (required for refresh tokens)
* `accounting.transactions.read` (for reading transaction data)
* `accounting.transactions` (for transaction operations)
* Add any additional scopes based on your needs
You can connect up to 25 organisations to uncertified apps. [Read more about uncertified app limits](https://developer.xero.com/guides/oauth2/limits/).
## Step 4: Get Your Credentials
After creating the app, you'll see:
* **Client ID**: Copy this value
* **Client Secret**: Generate and copy this value (keep it secure!)
You have successfully created a Xero OAuth application! You now have your Client ID and Client Secret ready for integration with Klavis AI.
### Xero Token Expiration
* **Access Tokens**: Expire after 30 minutes
* **Refresh Tokens**: Expire after 60 days (rolling expiration - resets when used)
**Klavis handles all token management automatically** - we refresh your tokens before they expire so you maintain seamless access to your Xero data without any interruption.
## (Optional) Step 5: White Labeling
White labeling allows you to customize the OAuth experience with your own branding instead of Klavis AI's.
If you want to use your own Xero OAuth application with custom branding:
1. **Configure White Labeling**: Go to [https://www.klavis.ai/home/white-label](https://www.klavis.ai/home/white-label)
2. **Add Your Credentials**: Enter your Xero **Client ID** and **Client Secret** from Step 4
3. **Set Redirect URI**: Use `https://api.klavis.ai/oauth/xero/callback` or your custom callback URL
4. **Initiate OAuth**: Use your client ID when starting the OAuth flow:
```javascript without SDK theme={null}
// Example: Initiating Xero OAuth with white-label
const authUrl = `https://api.klavis.ai/oauth/xero/authorize?instance_id=${instanceId}&client_id=${yourClientId}`;
window.location.href = authUrl;
```
```typescript TypeScript SDK theme={null}
import { Klavis } from "@klavis/sdk";
const klavis = new Klavis({
apiKey: "YOUR_API_KEY"
});
// Example: Initiating Xero OAuth with white-label
const oauthUrl = await klavis.mcpServer.getOAuthUrl({
serverName: Klavis.McpServerName.Xero,
instanceId: instanceId,
clientId: yourClientId,
// redirectUri: YOUR_REDIRECT_URI,
// scope: "YOUR_SCOPES",
});
window.location.href = oauthUrl;
```
```python Python SDK theme={null}
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
klavis = Klavis(api_key="YOUR_API_KEY")
# Example: Initiating Xero OAuth with white-label
oauth_url = klavis.mcp_server.get_oauth_url(
server_name=McpServerName.XERO,
instance_id=instance_id,
client_id=your_client_id,
# redirect_uri="YOUR_REDIRECT_URI",
# scope="YOUR_SCOPES"
)
# Open OAuth URL in user's default browser
webbrowser.open(oauth_url)
```
For detailed white labeling implementation and code examples, see our [OAuth & White Labeling guide](/auth/white-label).
## Resources
* [Xero Developer Documentation](https://developer.xero.com/)
* [Xero OAuth 2.0 Authentication Guide](https://developer.xero.com/guides/oauth2/overview/)
* [Klavis OAuth & White Labeling Guide](/auth/white-label)
* [Klavis White Label Dashboard](https://www.klavis.ai/home/white-label)
* [Xero API Scopes Reference](https://developer.xero.com/guides/oauth2/scopes/)
* [Xero OAuth Limits for Uncertified Apps](https://developer.xero.com/guides/oauth2/limits/)
# Create Your First MCP Server
Source: https://www.klavis.ai/docs/knowledge-base/onboarding/create-your-first-mcp-server
## Quick Start Guide
Create your first MCP server in 10 seconds using Gmail as an example.
Navigate to the [Klavis Dashboard](https://www.klavis.ai/home) and click **"MCP Server"** in the left sidebar.
Find the MCP server you like, here we use Gmail one as example.
You'll get a server URL and OAuth URL for authentication. Keep these handy for the next steps.
Once you hit the create button, it will automatically redirect you to the OAuth flow.
* Sign in to your Google account
* Grant Gmail permissions to Klavis
* You'll be redirected back automatically
* Your MCP server is now ready to use
Once OAuth is complete, your Gmail MCP server can read, send, and manage your emails.**Congratulations!** You've successfully created your first MCP server.
## Next Steps
Ready to start using it? Continue to [Use Your First MCP Server](/knowledge-base/onboarding/use-your-first-mcp-server).
# Use Your First MCP Server
Source: https://www.klavis.ai/docs/knowledge-base/onboarding/use-your-first-mcp-server
## Quick Start Guide
Use your MCP server in OpenAI Playground (for free) in 2 simple steps.
Go to [OpenAI Playground](https://platform.openai.com/chat/edit?models=gpt-4.1), then navigate to **Tools** ā **Add** ā **MCP Server**.
Enter your server configuration details and connect.
You can go to [Klavis Dashboard](https://www.klavis.ai/home) ā **MCP Server** ā **Manage Instances** to get your server URL if you forgot.
**Congratulations!** You've successfully used your first MCP server.
## What You Can Do with Gmail MCP Server
Fetch and analyze your latest emails with AI assistance
Compose and send emails through AI agents
Find specific emails using natural language queries
Organize emails with labels and folders automatically
# ChatGPT Connectors
Source: https://www.klavis.ai/docs/knowledge-base/use-mcp-server/chatgpt
Connect Strata with ChatGPT Connectors in minutes and supercharge your AI coding experience
## Quick Setup Guide
Navigate to the [Klavis home page](https://www.klavis.ai/home) and click **"MCP Server"** in the left sidebar. You will see a list of MCP servers available in Klavis.
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
You can authorize one or more servers to use with Strata
From Klavis Dashboard, click **Add to Other Clients** button to get your Strata Server URL.
**Copy** the strata URL to clipboard - you'll need this in the next step.
* Automatically redirected to OAuth authorization
* Sign in to your account (GitHub, Google, Slack, etc.)
* Grant necessary permissions
* Redirected back to Klavis automatically
* Prompted to enter an API key
* Follow service-specific instructions to generate key
* Paste key in the provided field
* Click **"Save"** to continue
To connect Klavis MCP Server with Connectors, you need to ensure **Developer Mode** is enabled.
* **Settings** -> **Apps & Connectors** -> **Advanced Settings** -> **Developer Mode** (enable it!)
**NOTE**: Developer Mode is required to add custom MCP servers in ChatGPT Connectors. See below screenshot for comparison:
Open a new chat in ChatGPT:
* Click on '**+**' icon or type `/`
* Select **Add Sources** > **Connect more**
Now, fill the essential detail to add new connector:
* **Icon** (Optional): Add icon for your MCP (128 \* 128 recommended)
* **Name**: `klavis-strata`
* **Description** (Optional): Short description of your MCP
* **MCP Server URL**: Paste Strata Server URL
* **Authentication**: select **No Authentication**
Tick 'I trust this application' and click **Create** button
Klavis AI authenticates your Strata server while generating server url.
To verify if Strata is configured properly in ChatGPT chat, click **"+"** -> **More** and you will see active servers.
To verify server tools:
* Go to **Setting** > **Apps & Connectors**
* Select your MCP > Scroll to **Actions** tab
Open ChatGPT Chat and start using natural language:
```text GitHub theme={null}
"Create a new issue titled 'Add dark mode' with priority label. Use Tools"
```
```text Slack theme={null}
"Send a message to #general: 'Standup meeting in 5 minutes! Use my MCP server'"
```
```text Gmail theme={null}
"Send email to john@company.com about project update. Use Tools"
```
```text Notion theme={null}
"Create a new page called 'Meeting Notes' with today's date. Use my MCP server"
```
šÆ ChatGPT Chat automatically detects when to use **Strata** based on context - no need to specify explicitly!
You're all set! Your **Strata** MCP server is now integrated with ChatGPT
## Troubleshooting
* Double-check your Server URL for typos
* Ensure stable internet connection
* Verify authentication in Klavis dashboard
* Try completely restarting ChatGPT
* Re-authenticate in the Klavis dashboard
* Check if your OAuth tokens have expired
* Verify API key permissions (for API key services)
* Ensure you've granted all necessary permissions
* Limit the number of active MCP servers
* Check your internet connection speed
* Restart ChatGPT periodically
* Contact support if issues persist
## Need Help?
Join our Discord for community support and discussions
Contact our technical support team for assistance
***
# Claude Code
Source: https://www.klavis.ai/docs/knowledge-base/use-mcp-server/claude_code
Connect Strata with Claude Code in minutes and supercharge your AI coding experience
## Quick Setup Guide
Navigate to the [Klavis home page](https://www.klavis.ai/home) and click **"MCP Server"** in the left sidebar. You will see a list of MCP servers available in Klavis.
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
You can authorize one or more servers to use with Strata
From Klavis Dashboard, click **"Add to Other Clients"** button to get your Strata Server URL.
**Copy** the strata URL to clipboard - you'll need this in the next step.
* Automatically redirected to OAuth authorization
* Sign in to your account (GitHub, Google, Slack, etc.)
* Grant necessary permissions
* Redirected back to Klavis automatically
* Prompted to enter an API key
* Follow service-specific instructions to generate key
* Paste key in the provided field
* Click **"Save"** to continue
Copy Your Server URL, open terminal and run the below command as shown in the screenshot below:
```bash theme={null}
claude mcp add klavis-strata npx mcp-remote
```
You can add **Single** MCP Server URL directly here as well:
1. Navigate to **Target Server** and click **Three Dots** next to your server
2. Tap **Show Individual Server URL** and copy the URL
3. Paste this URL in Claude Code as described above
To verify Strata server is configured properly, open Claude Code and run `/mcp` command.
To view available tools in the MCP server, navigate to Strata server and click `View Tools`.
š **Restart Claude Code** in terminal to apply the new configuration
Open Claude Code Chat and start using natural language:
```text GitHub theme={null}
"Create a new issue titled 'Add dark mode' with priority label"
```
```text Slack theme={null}
"Send a message to #general: 'Standup meeting in 5 minutes!'"
```
```text Gmail theme={null}
"Send email to john@company.com about project update"
```
```text Notion theme={null}
"Create a new page called 'Meeting Notes' with today's date"
```
šÆ Claude Code Chat automatically detects when to use **Strata** based on context - no need to specify explicitly!
* Remove MCP Server: `claude mcp remove klavis-strata`
* List all MCP Servers: `claude mcp list`
* Details of Strata: `claude mcp get klavis-strata`
You're all set! Your **Strata** MCP server is now integrated with Claude Code.
## Troubleshooting
* Double-check your Server URL for typos
* Ensure stable internet connection
* Verify authentication in Klavis dashboard
* Try completely restarting Claude Code
* Re-authenticate in the Klavis dashboard
* Check if your OAuth tokens have expired
* Verify API key permissions (for API key services)
* Ensure you've granted all necessary permissions
* Limit the number of active MCP servers
* Check your internet connection speed
* Restart Claude Code periodically
* Contact support if issues persist
## Need Help?
Join our Discord for community support and discussions
Contact our technical support team for assistance
***
# Claude Web/Desktop
Source: https://www.klavis.ai/docs/knowledge-base/use-mcp-server/claude_web_desktop
Connect Strata with Claude Web/Desktop in minutes and supercharge your AI coding experience
## Quick Setup Guide
Navigate to the [Klavis home page](https://www.klavis.ai/home) and click **"MCP Server"** in the left sidebar. You will see a list of MCP servers available in Klavis.
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
You can authorize one or more servers to use with Strata
From Klavis Dashboard, click **Add to Claude** button to get your Strata Server URL.
**Copy** the strata URL to clipboard - you'll need this in the next step.
* Automatically redirected to OAuth authorization
* Sign in to your account (GitHub, Google, Slack, etc.)
* Grant necessary permissions
* Redirected back to Klavis automatically
* Prompted to enter an API key
* Follow service-specific instructions to generate key
* Paste key in the provided field
* Click **"Save"** to continue
Copy Your Strata Server URL, open Claude Web/Desktop settings:
* **macOS**: `Cmd + ,` or **Claude Desktop > Settings > Connectors**
* **Windows/Linux**: `Ctrl + ,` or **Claude Desktop > Settings > Connectors**
Select **"Add Custom Connector"**:
* **Name**: `strata`
* **Remote MCP Server URL**: Paste your Strata Server URL that you copied earlier
Click **Add** to save the configuration. You can see strata added to the list.
You can add **Single** MCP Server URL directly here as well:
1. Navigate to **Target Server** and click **Three Dots** next to your server
2. Tap **Show Individual Server URL** and copy the URL
3. Paste this URL in Claude Web/Desktop settings as described above
To verify **Strata** tools are loading correctly, open new chat and click **Search and Tools** button (settings icon) and you will see **strata** enabled.
Open **strata** to see the list of tools available from your Strata MCP server.
š **Reopen Claude Web/Desktop Settings** to apply the new configuration
Open Claude Web/Desktop Chat (`Cmd/Ctrl + L`) and start using natural language:
```text GitHub theme={null}
"Create a new issue titled 'Add dark mode' with priority label"
```
```text Slack theme={null}
"Send a message to #general: 'Standup meeting in 5 minutes!'"
```
```text Gmail theme={null}
"Send email to john@company.com about project update"
```
```text Notion theme={null}
"Create a new page called 'Meeting Notes' with today's date"
```
šÆ Claude Web/Desktop Chat automatically detects when to use **Strata** based on context - no need to specify explicitly!
You're all set! Your **Strata** MCP server is now integrated with Claude Web/Desktop.
## Troubleshooting
* Double-check your Server URL for typos
* Ensure stable internet connection
* Verify authentication in Klavis dashboard
* Check Claude Web/Desktop logs for error messages
* Try completely restarting Claude Web/Desktop
* Re-authenticate in the Klavis dashboard
* Check if your OAuth tokens have expired
* Verify API key permissions (for API key services)
* Ensure you've granted all necessary permissions
* Limit the number of active MCP servers
* Check your internet connection speed
* Restart Claude Web/Desktop periodically
* Contact support if issues persist
## Need Help?
Join our Discord for community support and discussions
Contact our technical support team for assistance
***
# Cline
Source: https://www.klavis.ai/docs/knowledge-base/use-mcp-server/cline
Connect Strata with Cline in minutes and supercharge your AI coding experience
## Quick Setup Guide
Navigate to the [Klavis home page](https://www.klavis.ai/home) and click **"MCP Server"** in the left sidebar. You will see a list of MCP servers available in Klavis.
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
You can authorize one or more servers to use with Strata
From Klavis Dashboard, click **"Add to Other Clients"** button to get your Strata Server URL.
**Copy** the strata URL to clipboard - you'll need this in the next step.
You can add **Single** MCP Server URL directly here as well:
1. Navigate to **Target Server** and click **Three Dots** next to your server
2. Tap **Show Individual Server URL** and copy the URL
3. Paste this URL in Cline settings as described above
* Automatically redirected to OAuth authorization
* Sign in to your account (GitHub, Google, Slack, etc.)
* Grant necessary permissions
* Redirected back to Klavis automatically
* Prompted to enter an API key
* Follow service-specific instructions to generate key
* Paste key in the provided field
* Click **"Save"** to continue
Copy Your Server URL, click **Settings** -> **Manage MCP Servers**
Tap on **"Configure MCP Servers"** to open the configuration file.
Paste Your Server URL to **`cline_mcp_settings.json`** file like the screenshot below
To verify that Strata tools are loaded correctly, navigate to **Manage MCP Servers** > **Configure MCP Servers**.
š **Reopen Cline Settings** to apply the new configuration
Open Cline Chat and start using natural language:
```text GitHub theme={null}
"Create a new issue titled 'Add dark mode' with priority label"
```
```text Slack theme={null}
"Send a message to #general: 'Standup meeting in 5 minutes!'"
```
```text Gmail theme={null}
"Send email to john@company.com about project update"
```
```text Notion theme={null}
"Create a new page called 'Meeting Notes' with today's date"
```
šÆ Cline Chat automatically detects when to use **Strata** based on context - no need to specify explicitly!
You're all set! Your **Strata** MCP server is now integrated with Cline in VS Code IDE.
## Troubleshooting
* Double-check your Server URL for typos
* Ensure stable internet connection
* Verify authentication in Klavis dashboard
* Check VS Code logs (View ā Output ā Cline) for errors
* Try completely restarting VS Code IDE
* Re-authenticate in the Klavis dashboard
* Check if your OAuth tokens have expired
* Verify API key permissions (for API key services)
* Ensure you've granted all necessary permissions
* Limit the number of active MCP servers
* Check your internet connection speed
* Restart VS Code IDE periodically
* Contact support if issues persist
## Need Help?
Join our Discord for community support and discussions
Contact our technical support team for assistance
***
# Continue
Source: https://www.klavis.ai/docs/knowledge-base/use-mcp-server/continue
Connect Strata with Continue in minutes and supercharge your AI coding experience
## Quick Setup Guide
Navigate to the [Klavis home page](https://www.klavis.ai/home) and click **"MCP Server"** in the left sidebar. You will see a list of MCP servers available in Klavis.
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
You can authorize one or more servers to use with Strata
From Klavis Dashboard, click **"Add to Other Clients"** button to get your Strata Server URL.
**Copy** the strata URL to clipboard - you'll need this in the next step.
You can add **Single** MCP Server URL directly here as well:
1. Navigate to **Target Server** and click **Three Dots** next to your server
2. Tap **Show Individual Server URL** and copy the URL
3. Paste this URL in Continue settings as described above
* Automatically redirected to OAuth authorization
* Sign in to your account (GitHub, Google, Slack, etc.)
* Grant necessary permissions
* Redirected back to Klavis automatically
* Prompted to enter an API key
* Follow service-specific instructions to generate key
* Paste key in the provided field
* Click **"Save"** to continue
Copy Your Server URL, open **Configure Tools** (tools icon) -> **Tools** section
Click on "**+**" (plus icon) to create a new MCP server configuration for Strata
Paste Your Strata Server URL to **"new-mcp-server.yaml"** file like the screenshot below
To verify that Strata tools are loaded in Continue:
1. Open **Configure Tools** -> **Tools**
2. Under **MCP Servers**, tap **klavis-strata**
3. You should see the list of tools loaded from Strata server
š **Reopen Continue Settings** to apply the new configuration
Open Continue Chat (`Cmd/Ctrl + L`) and start using natural language:
```text GitHub theme={null}
"Create a new issue titled 'Add dark mode' with priority label"
```
```text Slack theme={null}
"Send a message to #general: 'Standup meeting in 5 minutes!'"
```
```text Gmail theme={null}
"Send email to john@company.com about project update"
```
```text Notion theme={null}
"Create a new page called 'Meeting Notes' with today's date"
```
šÆ Continue Chat automatically detects when to use **Strata** based on context - no need to specify explicitly!
You're all set! Your **Strata** is now integrated with Continue in VS Code IDE.
## Troubleshooting
* Double-check your Server URL for typos
* Ensure stable internet connection
* Verify authentication in Klavis dashboard
* Check VS Code logs (View ā Output ā Continue) for errors
* Try completely restarting VS Code IDE
* Re-authenticate in the Klavis dashboard
* Check if your OAuth tokens have expired
* Verify API key permissions (for API key services)
* Ensure you've granted all necessary permissions
* Limit the number of active MCP servers
* Check your internet connection speed
* Restart VS Code IDE periodically
* Contact support if issues persist
## Need Help?
Join our Discord for community support and discussions
Contact our technical support team for assistance
***
# Cursor
Source: https://www.klavis.ai/docs/knowledge-base/use-mcp-server/cursor
Connect Strata with Cursor IDE in minutes and supercharge your AI coding experience
## Quick Setup Guide
Navigate to the [Klavis home page](https://www.klavis.ai/home) and click **"MCP Server"** in the left sidebar. You will see a list of MCP servers available in Klavis.
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
You can authorize one or more servers to use with Strata
From Klavis Dashboard, click **Add to Cursor** and you will be redirected to Cursor.
Cursor will automatically open the **MCP** dialog with Strata Server URL pre-filled. Click **Install** to save the configuration.
Alternatively, you can configure **Strata** directly.
1. Go to **Setting** -> **MCP & Tools**
2. Click **Add Custom MCP**
3. Paste the below code in **mcp.json** file (See Screenshot below)
You can add **Single** MCP Server URL directly here as well:
1. Navigate to **Target Server** and click **Three Dots** next to your server
2. Tap **Show Individual Server URL** and copy the URL
3. Paste this URL in Cursor settings as described above
* Automatically redirected to OAuth authorization
* Sign in to your account (GitHub, Google, Slack, etc.)
* Grant necessary permissions
* Redirected back to Klavis automatically
* Prompted to enter an API key
* Follow service-specific instructions to generate key
* Paste key in the provided field
* Click **"Save"** to continue
In Cursor Settings, navigate to **Tools & MCP**. You will see **klavis-strata** listed under **Installed MCP Servers**.
Tap on **klavis-strata** to view the list of tools loaded from Strata server.
š **Reopen Cursor Settings** to apply the new configuration
Open Cursor Chat (`Cmd/Ctrl + L`) and start using natural language:
```text GitHub theme={null}
"Create a new issue titled 'Add dark mode' with priority label"
```
```text Slack theme={null}
"Send a message to #general: 'Standup meeting in 5 minutes!'"
```
```text Gmail theme={null}
"Send email to john@company.com about project update"
```
```text Notion theme={null}
"Create a new page called 'Meeting Notes' with today's date"
```
šÆ Cursor Chat automatically detects when to use **Strata** based on context - no need to specify explicitly!
You're all set! Your **Strata** is now integrated with Cursor IDE.
## Troubleshooting
* Double-check your Server URL for typos
* Ensure stable internet connection
* Verify authentication in Klavis dashboard
* Check Cursor IDE logs for error messages
* Try completely restarting Cursor IDE
* Re-authenticate in the Klavis dashboard
* Check if your OAuth tokens have expired
* Verify API key permissions (for API key services)
* Ensure you've granted all necessary permissions
* Limit the number of active MCP servers
* Check your internet connection speed
* Restart Cursor IDE periodically
* Contact support if issues persist
## Need Help?
Join our Discord for community support and discussions
Contact our technical support team for assistance
***
# Gemini CLI
Source: https://www.klavis.ai/docs/knowledge-base/use-mcp-server/gemini_cli
Connect Strata with Gemini CLI in minutes and supercharge your AI coding experience
## Quick Setup Guide
Navigate to the [Klavis home page](https://www.klavis.ai/home) and click **"MCP Server"** in the left sidebar. You will see a list of MCP servers available in Klavis.
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
You can authorize one or more servers to use with Strata
From Klavis Dashboard, click **"Add to Other Clients"** button to get your Strata Server URL.
**Copy** the strata URL to clipboard - you'll need this in the next step.
* Automatically redirected to OAuth authorization
* Sign in to your account (GitHub, Google, Slack, etc.)
* Grant necessary permissions
* Redirected back to Klavis automatically
* Prompted to enter an API key
* Follow service-specific instructions to generate key
* Paste key in the provided field
* Click **"Save"** to continue
Copy Your Server URL and navigate to `~/.gemini/settings.json` on your computer
Paste Your Server URL to **settings.json** file like the screenshot below
You can add **Single** MCP Server URL directly here as well:
1. Navigate to **Target Server** and click **Three Dots** next to your server
2. Tap **Show Individual Server URL** and copy the URL
3. Paste this URL in Gemini CLI settings as described above
To verify that Strata is properly configured in Gemini CLI, run **`/mcp`** command in Gemini CLI Chat.
š **Restart** Gemini CLI to apply the new configuration
Open Gemini CLI Chat and start using natural language:
```text GitHub theme={null}
"Create a new issue titled 'Add dark mode' with priority label"
```
```text Slack theme={null}
"Send a message to #general: 'Standup meeting in 5 minutes!'"
```
```text Gmail theme={null}
"Send email to john@company.com about project update"
```
```text Notion theme={null}
"Create a new page called 'Meeting Notes' with today's date"
```
šÆ Gemini CLI Chat automatically detects when to use **Strata** based on context - no need to specify explicitly!
You're all set! Your **Strata** is now integrated with Gemini CLI.
## Troubleshooting
* Double-check your Server URL for typos
* Ensure stable internet connection
* Verify authentication in Klavis dashboard
* Check Gemini CLI logs for error messages
* Try completely restarting Gemini CLI
* Re-authenticate in the Klavis dashboard
* Check if your OAuth tokens have expired
* Verify API key permissions (for API key services)
* Ensure you've granted all necessary permissions
* Limit the number of active MCP servers
* Check your internet connection speed
* Restart Gemini CLI periodically
* Contact support if issues persist
## Need Help?
Join our Discord for community support and discussions
Contact our technical support team for assistance
***
# Kiro
Source: https://www.klavis.ai/docs/knowledge-base/use-mcp-server/kiro
Connect Strata with Kiro in minutes and supercharge your AI workflow experience
## Quick Setup Guide
Navigate to the [Klavis home page](https://www.klavis.ai/home) and click **"MCP Server"** in the left sidebar. You will see a list of MCP servers available in Klavis.
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
You can authorize one or more servers to use with Strata
From Klavis Dashboard, click **"Add to Other Clients"** button to get your Strata Server URL.
**Copy** the strata URL to clipboard - you'll need this in the next step.
* Automatically redirected to OAuth authorization
* Sign in to your account (GitHub, Google, Slack, etc.)
* Grant necessary permissions
* Redirected back to Klavis automatically
* Prompted to enter an API key
* Follow service-specific instructions to generate key
* Paste key in the provided field
* Click **"Save"** to continue
Copy Your Server URL and configure Kiro with your MCP server settings.
You can add **Single** MCP Server URL directly here as well:
1. Navigate to **Target Server** and click **Three Dots** next to your server
2. Tap **Show Individual Server URL** and copy the URL
3. Paste this URL in Kiro settings as described above
š **Verify Tools Loading** - tools will automatically reload
Open Kiro and start using natural language to interact with your connected services:
```text GitHub theme={null}
"Create a new issue titled 'Add dark mode' with priority label"
```
```text Slack theme={null}
"Send a message to #general: 'Standup meeting in 5 minutes!'"
```
```text Gmail theme={null}
"Send email to john@company.com about project update"
```
```text Notion theme={null}
"Create a new page called 'Meeting Notes' with today's date"
```
šÆ Kiro automatically detects when to use **Strata** based on context - no need to specify explicitly!
You're all set! Your **Strata** MCP server is now integrated with Kiro.
## Troubleshooting
* Double-check your Server URL for typos
* Ensure stable internet connection
* Verify authentication in Klavis dashboard
* Check Kiro logs for error messages
* Try completely restarting Kiro
* Re-authenticate in the Klavis dashboard
* Check if your OAuth tokens have expired
* Verify API key permissions (for API key services)
* Ensure you've granted all necessary permissions
* Limit the number of active MCP servers
* Check your internet connection speed
* Restart Kiro periodically
* Contact support if issues persist
## Need Help?
Join our Discord for community support and discussions
Contact our technical support team for assistance
***
# n8n
Source: https://www.klavis.ai/docs/knowledge-base/use-mcp-server/n8n
Connect Strata with n8n in minutes and unlock powerful workflow automation
## Quick Setup Guide
Navigate to the [Klavis home page](https://www.klavis.ai/home) and click **"MCP Server"** in the left sidebar. You will see a list of MCP servers available in Klavis.
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
You can authorize one or more servers to use with Strata
From Klavis Dashboard, click **"Add to Other Clients"** button to get your Strata Server URL.
1. Navigate to **n8n**
2. MCP URL with custom auth headers enabled: `https://strata.klavis.ai/mcp/` (Copy it)
3. Click on **"Generate Token"** to get **Bearer Token** (Copy token & keep it secret!)
* Automatically redirected to OAuth authorization
* Sign in to your account (GitHub, Google, Slack, etc.)
* Grant necessary permissions
* Redirected back to Klavis automatically
* Prompted to enter an API key
* Follow service-specific instructions to generate key
* Paste key in the provided field
* Click **"Save"** to continue
## Build AI Workflow using Strata
Begin your automation by creating a **New Workflow** in your n8n personal workspace.
Click the **Add First Step ('+' icon)** and select **Trigger Manually** to kickstart your workflow and you should see your first node being created.
1. Click **"+ (What happens next?)"**
2. Navigate to **AI** ā **AI Agents** from the menu
3. Configure Your AI Agent:
* **Source for Prompt**: choose "Connected Chat Trigger Node"
* **Prompt**: `{{ $json.chatInput }}` (default setting)
4. Click **Back to Canvas** to save the agent
You should see **"When Chat Message Received"** and **"AI Agent"** nodes appear on the workflow diagram.
1. Click **"+ (Chat Model)"** -> **Anthropic Chat Model** (or your preferred model)
2. Connect Chat Model to **n8n** using API Key
3. Select **Model**: Claude Sonnet 4.5 (for example)
4. Click **Back to Canvas** to lock in your chat model configuration
Your **Chat Model** node now elegantly connects to your **AI Agent** node.
1. Click **"+ (Tool)"** -> **"MCP Client Tool"**
2. Configure Your MCP Client:
* Endpoint: Paste `https://strata.klavis.ai/mcp/`
* Server Transport: **HTTP Streamable**
* Authentication: **Bearer Auth**
* Credentials for Bearer Auth: Paste **Bearer Token** that you copied earlier
* Tools to Include: **All** (highly recommended for maximum capabilities)
3. Click **Back to Canvas** to save your MCP Client
To connect your bearer account to n8n, simply paste **"Bearer Token"** that you copied from Klavis Dashboard.
1. Navigate to **Connection** menu
2. Bearer Token: Paste your **"Bearer Auth Token"**
3. Allowed HTTP Request Domains: **All** (default settings)
Now, AI workflow diagram has been completed and should look similar to screenshot below.
Ready to test your workflow? Launch the chat interface in n8n by pressing **'C'** on your keyboard.
```text GitHub theme={null}
"Create a new issue titled 'Add dark mode' with priority label"
```
```text Slack theme={null}
"Send a message to #general: 'Standup meeting in 5 minutes!'"
```
```text Gmail theme={null}
"Send email to john@company.com about project update"
```
```text Notion theme={null}
"Create a new page called 'Meeting Notes' with today's date"
```
Once your chat executes successfully, celebrate as **Green Checkmarks** appear across all nodesāincluding your Model and MCP Client!
You're all set! Your **Strata** MCP server is now integrated with n8n.
## Troubleshooting
* Double-check your Server URL for typos
* Ensure stable internet connection
* Verify authentication in Klavis dashboard
* Check n8n logs for error messages
* Try completely restarting n8n
* Re-authenticate in the Klavis dashboard
* Check if your OAuth tokens have expired
* Verify API key permissions (for API key services)
* Ensure you've granted all necessary permissions
* Limit the number of active MCP servers (or Use Strata)
* Check your internet connection speed
* Restart n8n periodically
* Contact support if issues persist
## Need Help?
Join our Discord for community support and discussions
Contact our technical support team for assistance
***
# Overview
Source: https://www.klavis.ai/docs/knowledge-base/use-mcp-server/overview
Learn how to use MCP Servers in your favorite Client
# VS Code
Source: https://www.klavis.ai/docs/knowledge-base/use-mcp-server/vs_code
Connect Strata with VS Code in minutes and supercharge your AI coding experience
## Quick Setup Guide
Navigate to the [Klavis home page](https://www.klavis.ai/home) and click **"MCP Server"** in the left sidebar. You will see a list of MCP servers available in Klavis.
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
You can authorize one or more servers to use with Strata
From Klavis Dashboard, click **Add to VS Code** and you will be redirected to VS Code IDE.
VS Code will automatically open the **MCP** dialog with Strata Server URL pre-filled. Click **Install** to save the configuration.
Copy Your Strata URL, open **Command Palette** in VS Code settings:
* **macOS**: `Cmd + Shift + P`
* **Windows/Linux**: `Ctrl + Shift + P`
* Or **Settings > Command Palette > Preferences: Open User Setting (JSON)**
Paste Your Server URL to **settings.json** file like the screenshot below
You can add **Single** MCP Server URL directly here as well:
1. Navigate to **Target Server** and click **Three Dots** next to your server
2. Tap **Show Individual Server URL** and copy the URL
3. Paste this URL in VS Code settings as described above
* Automatically redirected to OAuth authorization
* Sign in to your account (GitHub, Google, Slack, etc.)
* Grant necessary permissions
* Redirected back to Klavis automatically
* Prompted to enter an API key
* Follow service-specific instructions to generate key
* Paste key in the provided field
* Click **"Save"** to continue
In Github Copilot Chat, open **"Configure Tools"** (Tools icon) and scroll down to **MCP Server: klavis-strata**. You will see the list of available tools in Strata.
As a prerequisite, you should have **GitHub Copilot Chat** extension installed in your VS Code IDE.
Open Chat (`Cmd/Ctrl + I`) and start using natural language:
```text GitHub theme={null}
"Create a new issue titled 'Add dark mode' with priority label"
```
```text Slack theme={null}
"Send a message to #general: 'Standup meeting in 5 minutes!'"
```
```text Gmail theme={null}
"Send email to john@company.com about project update"
```
```text Notion theme={null}
"Create a new page called 'Meeting Notes' with today's date"
```
šÆ Github Copilot Chat automatically detects when to use **Strata** based on context - no need to specify explicitly!
You're all set! Your **Strata** is now integrated with Github Copilot in VS Code IDE.
## Troubleshooting
* Double-check your Server URL for typos
* Ensure stable internet connection
* Verify authentication in Klavis dashboard
* Check VS Code logs (View ā Output ā GitHub Copilot) for errors
* Try completely restarting VS Code IDE
* Re-authenticate in the Klavis dashboard
* Check if your OAuth tokens have expired
* Verify API key permissions (for API key services)
* Ensure you've granted all necessary permissions
* Limit the number of active MCP servers
* Check your internet connection speed
* Restart VS Code IDE periodically
* Contact support if issues persist
## Need Help?
Join our Discord for community support and discussions
Contact our technical support team for assistance
***
# Windsurf
Source: https://www.klavis.ai/docs/knowledge-base/use-mcp-server/windsurf
Connect Strata with Windsurf IDE in minutes and supercharge your AI coding experience
## Quick Setup Guide
Navigate to the [Klavis home page](https://www.klavis.ai/home) and click **"MCP Server"** in the left sidebar. You will see a list of MCP servers available in Klavis.
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
You can authorize one or more servers to use with Strata
From Klavis Dashboard, click **"Add to Other Clients"** button to get your Strata Server URL.
**Copy** the strata URL to clipboard - you'll need this in the next step.
* Automatically redirected to OAuth authorization
* Sign in to your account (GitHub, Google, Slack, etc.)
* Grant necessary permissions
* Redirected back to Klavis automatically
* Prompted to enter an API key
* Follow service-specific instructions to generate key
* Paste key in the provided field
* Click **"Save"** to continue
Copy Your Server URL, open Windsurf IDE settings:
* **macOS**: `Cmd + ,` or **Windsurf > Settings > Advanced Settings**
* **Windows/Linux**: `Ctrl + ,` or **Windsurf > Settings > Advanced Settings**
Navigate to **Cascade** and click **Manage MCPs** > **View raw config**.
Paste Your Server URL to **mcp\_config.json** file like the screenshot below.
You can add **Single** MCP Server URL directly here as well:
1. Navigate to **Target Server** and click **Three Dots** next to your server
2. Tap **Show Individual Server URL** and copy the URL
3. Paste this URL in Windsurf settings as described above
š **Reopen Windsurf Settings** to apply the new configuration
Open Windsurf Chat (`Cmd/Ctrl + Shift + L`) and start using natural language:
```text GitHub theme={null}
"Create a new issue titled 'Add dark mode' with priority label"
```
```text Slack theme={null}
"Send a message to #general: 'Standup meeting in 5 minutes!'"
```
```text Gmail theme={null}
"Send email to john@company.com about project update"
```
```text Notion theme={null}
"Create a new page called 'Meeting Notes' with today's date"
```
šÆ Windsurf Chat automatically detects when to use **Strata** based on context - no need to specify explicitly!
You're all set! Your **Strata** MCP server is now integrated with Windsurf IDE.
## Troubleshooting
* Double-check your Server URL for typos
* Ensure stable internet connection
* Verify authentication in Klavis dashboard
* Check Windsurf IDE logs for error messages
* Try completely restarting Windsurf IDE
* Re-authenticate in the Klavis dashboard
* Check if your OAuth tokens have expired
* Verify API key permissions (for API key services)
* Ensure you've granted all necessary permissions
* Limit the number of active MCP servers
* Check your internet connection speed
* Restart Windsurf IDE periodically
* Contact support if issues persist
## Need Help?
Join our Discord for community support and discussions
Contact our technical support team for assistance
***
# MCP Server Instance
Source: https://www.klavis.ai/docs/legacy/instance
1:1 Mapping API to MCP Server Tool
This is the legacy approach to MCP servers. We recommend using [Strata MCP Server](/quickstart#strata) for better tool management and context window optimization.
Go to your Dashboard.
Choose an integration (for example, Gmail), and get the "individual server url"
Complete Auth by Click "Anthorize" button.
Add to your favorite MCP-supported clients, such as Cursor, Claude Code, VS Code, ChatGPT, etc.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```bash Curl theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/instance/create" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"serverName": "Gmail",
"userId": "user123"
}'
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_KLAVIS_API_KEY")
server = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.GMAIL,
user_id="user123",
)
print(server.server_url)
```
```javascript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavisClient = new KlavisClient({ apiKey: 'YOUR_KLAVIS_API_KEY' });
const server = await klavisClient.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Gmail,
userId: 'user123',
});
console.log(server.serverUrl);
```
**Response Information**: The API returns:
* `serverUrl`: The URL you'll use to connect your MCP client to the individual MCP Server
* `oauthUrl`: Authorization link if the service requires OAuth authentication
Full Individual MCP Server endpoints
```bash Curl theme={null}
Copy and paste the OAuth URL into your web browser
```
```python Python theme={null}
import webbrowser
if getattr(server, 'oauth_url', None):
webbrowser.open(server.oauth_url)
```
```javascript TypeScript theme={null}
if (server.oauthUrl) {
window?.open?.(server.oauthUrl);
}
```
**Authentication Methods**:
* **API Key**: See [API Key authentication guide](/auth/api-key) for details.
* **OAuth**: See [OAuth authentication guide](/auth/oauth) for details.
š **Your MCP Server URL is ready to use!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
```python Python theme={null}
import os
import asyncio
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
from langchain_openai import ChatOpenAI
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from dotenv import load_dotenv
load_dotenv()
async def main() -> None:
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
# Step 1: Create a single MCP server (e.g., Gmail)
response = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.GMAIL,
user_id="demo_user",
)
# Step 2: Handle OAuth authorization if needed
if hasattr(response, 'oauth_url') and response.oauth_url:
webbrowser.open(response.oauth_url)
input("Press Enter after completing OAuth authorization...")
# Step 3: Create LangChain Agent with MCP Tools
mcp_client = MultiServerMCPClient({
"gmail": {
"transport": "streamable_http",
"url": response.server_url,
}
})
# Get all available tools from the server
tools = await mcp_client.get_tools()
# Setup LLM
llm = ChatOpenAI(model="gpt-4o-mini", api_key=os.getenv("OPENAI_API_KEY"))
# Step 4: Create LangChain agent with MCP tools
agent = create_react_agent(
model=llm,
tools=tools,
prompt=(
"You are a helpful assistant that can use MCP tools. "
),
)
# Step 5: Invoke the agent
result = await agent.ainvoke({
"messages": [{"role": "user", "content": "Search my inbox for unread emails and summarize."}],
})
# Print only the final AI response content
print(result["messages"][-1].content)
if __name__ == "__main__":
asyncio.run(main())
```
```python Python theme={null}
import os
import asyncio
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
from llama_index.llms.openai import OpenAI
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.tools.mcp import BasicMCPClient
from llama_index.tools.mcp import (
aget_tools_from_mcp_url,
)
from dotenv import load_dotenv
load_dotenv()
async def main() -> None:
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
# Step 1: Create a single MCP server (e.g., Gmail)
response = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.GMAIL,
user_id="demo_user",
)
# Step 2: Handle OAuth authorization if needed
if hasattr(response, 'oauth_url') and response.oauth_url:
webbrowser.open(response.oauth_url)
input("Press Enter after completing OAuth authorization...")
# Step 3: Create LlamaIndex Agent with MCP Tools
tools = await aget_tools_from_mcp_url(
response.server_url,
client=BasicMCPClient(response.server_url)
)
# Setup LLM
llm = OpenAI(model="gpt-4o-mini", api_key=os.getenv("OPENAI_API_KEY"))
# Step 4: Create LlamaIndex agent with MCP tools
agent = FunctionAgent(
name="gmail_agent",
description="Agent using Gmail MCP tools",
tools=tools,
llm=llm,
system_prompt=(
"You are a helpful assistant that can use MCP tools. "
),
)
# Step 5: Invoke the agent
result = await agent.run(
"Search my inbox for unread emails and summarize."
)
# Print the response
print(result)
if _name_ == "_main_":
asyncio.run(main())
```
Coming soon
```python Python theme={null}
import os
import asyncio
import webbrowser
from dotenv import load_dotenv
from klavis import Klavis
from klavis.types import McpServerName
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.ui import Console
from autogen_core import CancellationToken
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import StreamableHttpMcpToolAdapter, StreamableHttpServerParams
from autogen_ext.tools.mcp import mcp_server_tools
load_dotenv()
async def main() -> None:
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
# Create MCP server instance
response = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.GMAIL,
user_id="demo_user",
)
# Handle OAuth authorization if required
if getattr(response, "oauth_url", None):
webbrowser.open(response.oauth_url)
input("Press Enter after completing OAuth authorization...")
server_params = StreamableHttpServerParams(
url=response.server_url,
timeout=30.0,
sse_read_timeout=300.0,
terminate_on_close=True,
)
adapters = await mcp_server_tools(server_params)
model_client = OpenAIChatCompletionClient(model="gpt-4")
agent = AssistantAgent(
name="MailAI",
model_client=model_client,
tools=adapters,
system_message="You are a helpful Gmail assistant.",
)
await Console(
agent.run_stream(
task="Find My Latest Emails",
cancellation_token=CancellationToken()
)
)
if __name__ == "__main__":
asyncio.run(main())
```
Visit [https://github.com/Klavis-AI/klavis/mcp\_servers](https://github.com/Klavis-AI/klavis/mcp_servers) to view the source code and find more information
```bash Docker theme={null}
docker run -p 5000:5000 ghcr.io/klavis-ai/gmail-mcp-server:latest
```
Browse all available MCP server Docker images at [GitHub Packages](https://github.com/orgs/Klavis-AI/packages?repo_name=klavis)
Use the local URL (for example, [http://localhost:5000](http://localhost:5000)) in your client or aggregator.
Add TLS, auth, and deploy behind your gateway as needed.
For the recommended approach with better tool management and progressive discovery, see [Strata MCP Server](/quickstart#strata).
# Affinity
Source: https://www.klavis.ai/docs/mcp-server/affinity
Connect AI agents to Affinity CRM for managing contacts, deals, and relationships
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Affinity CRM to manage relationships, track deals, and organize contacts through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Affinity
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.AFFINITY],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Affinity
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Affinity],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Affinity"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.AFFINITY,
auth_data={
"api_key": "YOUR_AFFINITY_API_KEY"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Affinity,
authData: {
api_key: "YOUR_AFFINITY_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Affinity",
"authData": {
"api_key": "YOUR_AFFINITY_API_KEY"
}
}'
```
Get your Affinity API key from your [Affinity Settings](https://app.affinity.co/settings/api).
š **Your Affinity MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Affinity from the list of available integrations.
Complete the OAuth flow to connect your Affinity account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/affinity
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/affinity-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/affinity-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_affinity_api_key"}' \
ghcr.io/klavis-ai/affinity-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"affinity": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Affinity. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Airtable
Source: https://www.klavis.ai/docs/mcp-server/airtable
Connect AI agents to Airtable for managing databases, records, and workflows
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Airtable to manage databases, automate workflows, and sync data through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.AIRTABLE],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Airtable
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Airtable],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Airtable"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.AIRTABLE])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Airtable]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/airtable/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Airtable MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Airtable from the list of available integrations.
Complete the OAuth flow to connect your Airtable account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/airtable
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/airtable-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/airtable-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_airtable_api_key"}' \
ghcr.io/klavis-ai/airtable-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"airtable": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Airtable. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Asana
Source: https://www.klavis.ai/docs/mcp-server/asana
Connect AI agents to Asana for managing projects, tasks, and team collaboration
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Asana to manage projects, track tasks, and collaborate with your team through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.ASANA],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Asana
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Asana],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Asana"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.ASANA])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Asana]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/asana/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Asana MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Asana from the list of available integrations.
Complete the OAuth flow to connect your Asana account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/asana
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/asana-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/asana-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_asana_api_key"}' \
ghcr.io/klavis-ai/asana-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"asana": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Asana. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Attio
Source: https://www.klavis.ai/docs/mcp-server/attio
Connect AI agents to Attio for CRM management and customer relationship tracking
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Attio to manage your CRM data, track customer relationships, and automate sales processes through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.ATTIO],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Attio
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Attio],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Attio"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.ATTIO])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Attio]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/attio/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Attio MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Attio from the list of available integrations.
Complete the OAuth flow to connect your Attio workspace.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/attio
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/attio-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/attio-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_attio_token"}' \
ghcr.io/klavis-ai/attio-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"attio": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Attio. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Box
Source: https://www.klavis.ai/docs/mcp-server/box
Connect AI agents to Box for managing files and collaboration
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Box to manage files and collaboration through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Box
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.BOX],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Box
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Box],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Box"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.BOX])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Box]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/box/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your Box API key from your [Box Developer Console](https://developer.box.com/).
š **Your Box MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Box from the list of available integrations.
Complete the OAuth flow to connect your Box account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/box
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/box-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/box-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_box_api_key"}' \
ghcr.io/klavis-ai/box-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"box": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Box. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Brave Search
Source: https://www.klavis.ai/docs/mcp-server/brave_search
Connect AI agents to Brave Search for web, image, news, and video search capabilities
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Brave Search to perform comprehensive web searches, including web results, images, news, and videos through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Brave Search
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.BRAVE_SEARCH],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Brave Search
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.BraveSearch],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Brave Search"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.BRAVE_SEARCH,
auth_data={
"api_key": "YOUR_BRAVE_SEARCH_API_KEY"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.BraveSearch,
authData: {
api_key: "YOUR_BRAVE_SEARCH_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Brave Search",
"authData": {
"api_key": "YOUR_BRAVE_SEARCH_API_KEY"
}
}'
```
š **Your Brave Search MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Brave Search from the list of available integrations.
Enter your Brave Search API key to enable search functionality.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/brave_search
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/brave-search-mcp-server:latest
# Run with Brave Search API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"api_key":"your_brave_search_api_key"}' \
ghcr.io/klavis-ai/brave-search-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"brave_search": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Brave Search. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Cal.com
Source: https://www.klavis.ai/docs/mcp-server/cal_com
Connect AI agents to Cal.com for scheduling and calendar management
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Cal.com to manage schedules, create appointments, and automate calendar operations through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.CAL_COM],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Cal.com
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.CalCom],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["CalCom"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.CAL_COM])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.CalCom]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/cal_com/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Cal.com MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Cal.com from the list of available integrations.
Complete the OAuth flow to connect your Cal.com account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/cal_com
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/cal-com-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/cal-com-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_cal_com_token"}' \
ghcr.io/klavis-ai/cal-com-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"cal_com": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Cal.com. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Calendly
Source: https://www.klavis.ai/docs/mcp-server/calendly
Connect AI agents to Calendly for automated scheduling and calendar management
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Calendly to automate scheduling, manage appointments, and integrate calendar functionality through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.CALENDLY],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Calendly
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Calendly],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Calendly"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.CALENDLY])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Calendly]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/calendly/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Calendly MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Calendly from the list of available integrations.
Complete the OAuth flow to connect your Calendly account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/calendly
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/calendly-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/calendly-mcp-server:latest
# Or run with manual OAuth token
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_calendly_oauth_token"}' \
ghcr.io/klavis-ai/calendly-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"calendly": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Calendly. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# ClickUp
Source: https://www.klavis.ai/docs/mcp-server/clickup
Connect AI agents to ClickUp for project management and task tracking
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to ClickUp to manage projects, track tasks, and automate workflow operations through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.CLICKUP],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with ClickUp
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.ClickUp],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["ClickUp"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.CLICKUP])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.ClickUp]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/clickup/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your ClickUp MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select ClickUp from the list of available integrations.
Complete the OAuth flow to connect your ClickUp workspace.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/clickup
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/clickup-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/clickup-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_clickup_token"}' \
ghcr.io/klavis-ai/clickup-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"clickup": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for ClickUp. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Close
Source: https://www.klavis.ai/docs/mcp-server/close
Connect AI agents to Close CRM for sales pipeline management and lead automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Close CRM to manage leads, contacts, opportunities, and automate sales workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.CLOSE],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Close
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Close],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Close"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.CLOSE])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Close]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/close/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Close CRM MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Close from the list of available integrations.
Complete the OAuth flow to connect your Close CRM account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/close
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/close-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/close-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"close": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Close. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Cloudflare
Source: https://www.klavis.ai/docs/mcp-server/cloudflare
Connect AI agents to Cloudflare for CDN, security, and edge computing management
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Cloudflare to manage DNS records, deploy Workers, configure firewalls, and optimize web performance through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Cloudflare
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.CLOUDFLARE],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Cloudflare
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Cloudflare],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Cloudflare"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.CLOUDFLARE,
auth_data={
"api_key": "YOUR_CLOUDFLARE_API_KEY"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Cloudflare,
authData: {
api_key: "YOUR_CLOUDFLARE_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Cloudflare",
"authData": {
"api_key": "YOUR_CLOUDFLARE_API_KEY"
}
}'
```
š **Your Cloudflare MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Cloudflare from the list of available integrations.
Enter your Cloudflare API key to authenticate the connection.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/cloudflare
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/cloudflare-mcp-server:latest
# Run with API key support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/cloudflare-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"cloudflare": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Cloudflare. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Coinbase
Source: https://www.klavis.ai/docs/mcp-server/coinbase
Connect AI agents to Coinbase for cryptocurrency data and portfolio management
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Coinbase to access cryptocurrency prices, manage portfolios, and track transactions through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Coinbase
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.COINBASE],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Coinbase
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Coinbase],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Coinbase"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.COINBASE,
auth_data={
"api_key": "YOUR_COINBASE_API_KEY",
"secret_key": "YOUR_COINBASE_API_SECRET"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Coinbase,
authData: {
api_key: "YOUR_COINBASE_API_KEY",
secret_key: "YOUR_COINBASE_API_SECRET"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Coinbase",
"authData": {
"api_key": "YOUR_COINBASE_API_KEY",
"secret_key": "YOUR_COINBASE_API_SECRET"
}
}'
```
š **Your Coinbase MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Coinbase from the list of available integrations.
Enter your Coinbase API key and secret to enable cryptocurrency data access.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/coinbase
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/coinbase-mcp-server:latest
# Run with Coinbase API credentials
docker run -p 5000:5000 \
-e AUTH_DATA='{"api_key":"your_coinbase_api_key","secret_key":"your_coinbase_secret"}' \
ghcr.io/klavis-ai/coinbase-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"coinbase": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Coinbase. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Confluence
Source: https://www.klavis.ai/docs/mcp-server/confluence
Connect AI agents to Confluence for document management and collaborative editing
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Confluence to manage documents, create and edit pages, organize spaces, and collaborate on content through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.CONFLUENCE],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Confluence
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Confluence],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Confluence"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.CONFLUENCE])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Confluence]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/confluence/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Confluence MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Confluence from the list of available integrations.
Complete the OAuth flow to connect your Confluence workspace.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/confluence
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/confluence-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/confluence-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_confluence_token"}' \
ghcr.io/klavis-ai/confluence-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"confluence": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Confluence. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Dialpad
Source: https://www.klavis.ai/docs/mcp-server/dialpad
Connect to Dialpad for AI-Powered Customer Communication Platform
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Dialpad for AI-Powered Customer Communication Platform
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Dialpad
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.DIALPAD],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Dialpad
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.DIALPAD],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["DIALPAD"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.DIALPAD])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.DIALPAD]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/dialpad/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your Dialpad API key from your [Dialpad Developer Console](https://developers.dialpad.com/).
š **Your Dialpad MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Dialpad from the list of available integrations.
Complete the OAuth flow to connect your Dialpad account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/dialpad
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/dialpad-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/dialpad-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_dialpad_api_key"}' \
ghcr.io/klavis-ai/dialpad-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"dialpad": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Dialpad. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Discord
Source: https://www.klavis.ai/docs/mcp-server/discord
Connect AI agents to Discord for server management and communication
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Discord to manage servers, send messages, and interact with communities through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Discord
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.DISCORD],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Discord
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Discord],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Discord"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.DISCORD,
auth_data={
"data": {
"bot_token": "YOUR_DISCORD_BOT_TOKEN"
}
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Discord,
authData: {
data: {
bot_token: "YOUR_DISCORD_BOT_TOKEN"
}
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Discord",
"authData": {
"data": {
"bot_token": "YOUR_DISCORD_BOT_TOKEN"
}
}
}'
```
Get your Discord bot token from the [Discord Developer Portal](https://discord.com/developers/applications). You'll also need to add the bot to your Discord server with the required permissions.
š **Your Discord MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Discord from the list of available integrations.
Complete the OAuth flow to connect your Discord bot.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/discord
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/discord-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/discord-mcp-server:latest
# Or run with manual bot token
docker run -p 5000:5000 \
-e AUTH_DATA='{"bot_token":"your_discord_bot_token"}' \
ghcr.io/klavis-ai/discord-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"discord": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Discord. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Doc2markdown
Source: https://www.klavis.ai/docs/mcp-server/doc2markdown
Connect AI agents to Doc2markdown for document format conversion
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Doc2markdown to convert various document formats (PDF, PowerPoint, Word, Excel, HTML, ZIP files, and EPubs) to markdown through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Doc2markdown
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.DOC2MARKDOWN],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Doc2markdown
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Doc2markdown],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Doc2markdown"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
š **Your Doc2markdown MCP Server is ready!** You can now use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Doc2markdown from the list of available integrations.
Enter your Doc2markdown API key to authenticate the connection.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/doc2markdown
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/doc2markdown-mcp-server:latest
# Run with API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"api_key":"your_doc2markdown_api_key"}' \
ghcr.io/klavis-ai/doc2markdown-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"doc2markdown": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Doc2markdown. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Docusign
Source: https://www.klavis.ai/docs/mcp-server/docusign
Connect AI agents to Docusign for Electronic Signatures and Agreements
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect AI agents to Docusign for Electronic Signatures and Agreements
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Docusign
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.DOCUSIGN],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Docusign
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.DOCUSIGN],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["DOCUSIGN"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.DOCUSIGN])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.DOCUSIGN]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/docusign/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your Docusign API key from your [Docusign Developer Console](https://developers.docusign.com/).
š **Your Docusign MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Docusign from the list of available integrations.
Complete the OAuth flow to connect your Docusign account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/docusign
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/docusign-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/docusign-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_docusign_api_key"}' \
ghcr.io/klavis-ai/docusign-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"docusign": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Docusign. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Dropbox
Source: https://www.klavis.ai/docs/mcp-server/dropbox
Connect AI agents to Dropbox for file storage and collaboration management
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Dropbox to manage files, organize folders, share content, and automate file operations through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.DROPBOX],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Dropbox
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Dropbox],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Dropbox"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.DROPBOX])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Dropbox]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/dropbox/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Dropbox MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Dropbox from the list of available integrations.
Complete the OAuth flow to connect your Dropbox account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/dropbox
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/dropbox-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/dropbox-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_dropbox_token"}' \
ghcr.io/klavis-ai/dropbox-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"dropbox": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Dropbox. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# ElevenLabs
Source: https://www.klavis.ai/docs/mcp-server/elevenlabs
Connect AI agents to ElevenLabs for managing voice and audio
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to ElevenLabs to manage voice and audio through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with ElevenLabs
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.ELEVENLABS],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with ElevenLabs
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.ELEVENLABS],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["ElevenLabs"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.ELEVENLABS])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.ELEVENLABS]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/elevenlabs/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your ElevenLabs API key from your [ElevenLabs Developer Console](https://elevenlabs.io/developers).
š **Your ElevenLabs MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select ElevenLabs from the list of available integrations.
Complete the OAuth flow to connect your ElevenLabs account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/elevenlabs
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/elevenlabs-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/elevenlabs-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_elevenlabs_api_key"}' \
ghcr.io/klavis-ai/elevenlabs-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"elevenlabs": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for ElevenLabs. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Exa
Source: https://www.klavis.ai/docs/mcp-server/exa
Connect AI agents to Exa for AI-powered semantic search and content discovery
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Exa to perform AI-powered semantic search, content retrieval, and comprehensive research through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Exa
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.EXA],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Exa
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Exa],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Exa"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.EXA,
auth_data={
"api_key": "YOUR_EXA_API_KEY"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Exa,
authData: {
api_key: "YOUR_EXA_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Exa",
"authData": {
"api_key": "YOUR_EXA_API_KEY"
}
}'
```
Get your Exa API key from the [Exa AI website](https://docs.exa.ai/reference/getting-started).
š **Your Exa MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Exa from the list of available integrations.
Enter your Exa API key to enable semantic search functionality.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/exa
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/exa-mcp-server:latest
# Run with Exa API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"api_key":"your_exa_api_key"}' \
ghcr.io/klavis-ai/exa-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"exa": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Exa. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Fathom
Source: https://www.klavis.ai/docs/mcp-server/fathom
Connect to Fathom for AI-Powered Notes and Summaries
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Fathom for AI-Powered Notes and Summaries
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Fathom
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.FATHOM],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Fathom
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.FATHOM],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Fathom"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.FATHOM])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.FATHOM]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/fathom/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Fathom integration is ready!**
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Fathom from the list of available integrations.
Complete the OAuth flow to connect your Fathom account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/fathom
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/fathom-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/fathom-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_fathom_api_key"}' \
ghcr.io/klavis-ai/fathom-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"fathom": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Fathom. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Figma
Source: https://www.klavis.ai/docs/mcp-server/figma
Connect AI agents to Figma for design collaboration and asset management
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Figma to access design files, manage assets, retrieve comments, and collaborate on design projects through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.FIGMA],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Figma
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Figma],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Figma"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.FIGMA])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Figma]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/figma/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Figma MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Figma from the list of available integrations.
Complete the OAuth flow to connect your Figma account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/figma
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/figma-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/figma-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"api_key":"your_figma_api_key"}' \
ghcr.io/klavis-ai/figma-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"figma": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Figma. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Firecrawl Deep Research
Source: https://www.klavis.ai/docs/mcp-server/firecrawl-deep-research
Connect AI agents to Firecrawl Deep Research for comprehensive web-based research and analysis
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Firecrawl Deep Research to perform comprehensive web-based research, analysis, and in-depth topic exploration through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Firecrawl Deep Research
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.FIRECRAWL_DEEP_RESEARCH],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Firecrawl Deep Research
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.FirecrawlDeepResearch],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Firecrawl Deep Research"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
You can get your Firecrawl API key from the [Firecrawl website](https://firecrawl.dev/).
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.FIRECRAWL_DEEP_RESEARCH,
auth_data={
"api_key": "YOUR_FIRECRAWL_API_KEY"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.FirecrawlDeepResearch,
authData: {
api_key: "YOUR_FIRECRAWL_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Firecrawl Deep Research",
"authData": {
"api_key": "YOUR_FIRECRAWL_API_KEY"
}
}'
```
š **Your Firecrawl Deep Research MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Firecrawl Deep Research from the list of available integrations.
Enter your Firecrawl API key to enable research functionality.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/firecrawl_deep_research
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/firecrawl-deep-research-mcp-server:latest
# Run with API key support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/firecrawl-deep-research-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"firecrawl_deep": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Firecrawl Deep Research. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Firecrawl Web Search
Source: https://www.klavis.ai/docs/mcp-server/firecrawl-web-search
Connect AI agents to Firecrawl Web Search for advanced web scraping and content extraction
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Firecrawl Web Search to perform advanced web scraping, content extraction, and automated web crawling through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Firecrawl Web Search
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.FIRECRAWL_WEB_SEARCH],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Firecrawl Web Search
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.FirecrawlWebSearch],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Firecrawl Web Search"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
You can get your Firecrawl API key from the [Firecrawl website](https://firecrawl.dev/).
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.FIRECRAWL_WEB_SEARCH,
auth_data={
"api_key": "YOUR_FIRECRAWL_API_KEY"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.FirecrawlWebSearch,
authData: {
api_key: "YOUR_FIRECRAWL_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Firecrawl Web Search",
"authData": {
"api_key": "YOUR_FIRECRAWL_API_KEY"
}
}'
```
š **Your Firecrawl Web Search MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Firecrawl Web Search from the list of available integrations.
Enter your Firecrawl API key to enable web scraping functionality.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/firecrawl
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/firecrawl-web-search-mcp-server:latest
# Run with API key support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/firecrawl-web-search-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"firecrawl": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Firecrawl Web Search. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Fireflies
Source: https://www.klavis.ai/docs/mcp-server/fireflies
Connect AI agents to Fireflies for automated meeting transcription, note-taking, and conversation analysis
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Fireflies to transcribe meetings, extract insights, search conversations, and automate meeting workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Fireflies
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.FIREFLIES],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Fireflies
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Fireflies],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Fireflies"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.FIREFLIES,
auth_data={
"api_key": "YOUR_FIREFLIES_API_KEY"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Fireflies,
authData: {
api_key: "YOUR_FIREFLIES_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Fireflies",
"authData": {
"api_key": "YOUR_FIREFLIES_API_KEY"
}
}'
```
š **Your Fireflies MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Fireflies from the list of available integrations.
Enter your Fireflies API key to connect.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/fireflies
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/fireflies-mcp-server:latest
# Run with API key support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/fireflies-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"fireflies": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Fireflies. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Freshdesk
Source: https://www.klavis.ai/docs/mcp-server/freshdesk
Connect AI agents to Freshdesk for managing customer support
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Freshdesk to manage customer support through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Freshdesk
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.FRESHDESK],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Freshdesk
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Freshdesk],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Freshdesk"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.FRESHDESK])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Freshdesk]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/freshdesk/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your Freshdesk API key from your [Freshdesk Developer Console](https://developers.freshdesk.com/).
š **Your Freshdesk MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Freshdesk from the list of available integrations.
Complete the OAuth flow to connect your Freshdesk account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/freshdesk
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/freshdesk-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/freshdesk-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_freshdesk_api_key"}' \
ghcr.io/klavis-ai/freshdesk-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"freshdesk": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Freshdesk. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# GitHub
Source: https://www.klavis.ai/docs/mcp-server/github
Connect AI agents to GitHub for repository management and code collaboration
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to GitHub to manage repositories, track issues, and collaborate on code through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GITHUB],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with GitHub
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Github],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["GitHub"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.GITHUB])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Github]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/github/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your GitHub MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select GitHub from the list of available integrations.
Complete the OAuth flow to connect your GitHub account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/github
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/github-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/github-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_github_token"}' \
ghcr.io/klavis-ai/github-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"github": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for GitHub. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# GitLab
Source: https://www.klavis.ai/docs/mcp-server/gitlab
Connect AI agents to GitLab for source control, CI/CD, and DevOps automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to GitLab to manage source control, CI/CD, and DevOps automation through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Gitlab
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GITLAB],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Gitlab
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Gitlab],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Gitlab"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.GITLAB])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Gitlab]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/gitlab/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your Gitlab API key from your [Gitlab Developer Console](https://developer.gitlab.com/).
š **Your Gitlab MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Gitlab from the list of available integrations.
Complete the OAuth flow to connect your Gitlab account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/gitlab
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/gitlab-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/gitlab-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_gitlab_api_key"}' \
ghcr.io/klavis-ai/gitlab-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"gitlab": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for GitLab. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Gmail
Source: https://www.klavis.ai/docs/mcp-server/gmail
Connect AI agents to Gmail for email management and communication
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Gmail to manage emails, organize conversations, and automate communication through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GMAIL],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Gmail
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Gmail],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Gmail"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.GMAIL])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Gmail]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/gmail/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Gmail MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Gmail from the list of available integrations.
Complete the OAuth flow to connect your Gmail account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/gmail
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/gmail-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/gmail-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_gmail_token"}' \
ghcr.io/klavis-ai/gmail-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"gmail": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Gmail. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Gong
Source: https://www.klavis.ai/docs/mcp-server/gong
Connect AI agents to Gong for sales conversation intelligence and call analytics
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Gong to access sales conversation intelligence, analyze call transcripts, and extract insights from sales meetings through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Gong
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GONG],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Gong
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Gong],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Gong"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
You can get your Gong API key from your Gong admin settings. Contact your Gong administrator for access.
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.GONG,
auth_data={
"api_key": "YOUR_GONG_API_KEY"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Gong,
authData: {
api_key: "YOUR_GONG_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Gong",
"authData": {
"api_key": "YOUR_GONG_API_KEY"
}
}'
```
š **Your Gong MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Gong from the list of available integrations.
Enter your Gong API key to enable conversation intelligence access.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/gong
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/gong-mcp-server:latest
# Run with API key support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/gong-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"gong": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Gong. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Google Calendar
Source: https://www.klavis.ai/docs/mcp-server/google_calendar
Connect AI agents to Google Calendar for event management and scheduling automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Google Calendar to manage events, schedule meetings, and automate calendar operations through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GOOGLE_CALENDAR],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Google Calendar
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.GoogleCalendar],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"serverName": "Google Calendar",
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.GOOGLE_CALENDAR])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.GoogleCalendar]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/gcalendar/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Google Calendar MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Google Calendar from the list of available integrations.
Complete the OAuth flow to connect your Google Calendar account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/google_calendar
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/google-calendar-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/google-calendar-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"google_calendar": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Google Calendar. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Google Docs
Source: https://www.klavis.ai/docs/mcp-server/google_docs
Connect AI agents to Google Docs for document creation and collaboration
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Google Docs to create, edit, and manage Google Docs documents and collaborate on content through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GOOGLE_DOCS],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Google Docs
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.GoogleDocs],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"serverName": "Google Docs",
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.GOOGLE_DOCS])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.GoogleDocs]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/gdocs/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Google Docs MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Google Docs from the list of available integrations.
Complete the OAuth flow to connect your Google Docs account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/google_docs
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/google-docs-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/google-docs-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"google_docs": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Google Docs. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Google Drive
Source: https://www.klavis.ai/docs/mcp-server/google_drive
Connect AI agents to Google Drive for file storage and collaboration
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Google Drive to manage files, folders, permissions, and organize cloud storage through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GOOGLE_DRIVE],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Google Drive
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.GoogleDrive],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"serverName": "Google Drive",
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.GOOGLE_DRIVE])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.GoogleDrive]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/gdrive/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Google Drive MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Google Drive from the list of available integrations.
Complete the OAuth flow to connect your Google Drive account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/google_drive
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/google-drive-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/google-drive-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"google_drive": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Google Drive. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Google Jobs
Source: https://www.klavis.ai/docs/mcp-server/google_jobs
Connect AI agents to Google Jobs for managing job postings and applications
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Google Jobs to manage job postings and applications through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Google Jobs
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GOOGLE_JOBS],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Google Jobs
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.GoogleJobs],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["GoogleJobs"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.GOOGLE_JOBS])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.GoogleJobs]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/google_jobs/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Google Jobs MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Google Jobs from the list of available integrations.
Complete the OAuth flow to connect your Google Jobs account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/google_jobs
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/google-jobs-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/google-jobs-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_google_jobs_api_key"}' \
ghcr.io/klavis-ai/google-jobs-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"google_jobs": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Google Jobs. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Google Sheets
Source: https://www.klavis.ai/docs/mcp-server/google_sheets
Connect AI agents to Google Sheets for spreadsheet automation and data management
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Google Sheets to create, read, and manage spreadsheets and automate data workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.GOOGLE_SHEETS],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Google Sheets
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.GoogleSheets],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"serverName": "Google Sheets",
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.GOOGLE_SHEETS])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.GoogleSheets]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/gsheets/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Google Sheets MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Google Sheets from the list of available integrations.
Complete the OAuth flow to connect your Google account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/google_sheets
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/google-sheets-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/google-sheets-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"google_sheets": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Watch the Example
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Google Sheets. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Hacker News
Source: https://www.klavis.ai/docs/mcp-server/hacker_news
Connect AI agents to Hacker News for news aggregation and content analysis
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Hacker News to fetch stories, user profiles, and analyze technology news through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Hacker News
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.HACKER_NEWS],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Hacker News
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.HackerNews],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Hacker News"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
š **Your Hacker News MCP Server is ready!** You can now use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Hacker News from the list of available integrations.
No authentication required - your server is immediately ready.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/hacker_news
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/hacker-news-mcp-server:latest
# Run the server (no API key required for Hacker News)
docker run -p 5000:5000 \
ghcr.io/klavis-ai/hacker-news-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"hacker_news": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Hacker News. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# HeyGen
Source: https://www.klavis.ai/docs/mcp-server/heygen
Connect AI agents to HeyGen for AI-powered video generation and avatar creation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to HeyGen to generate AI-powered videos with avatars, manage video content, and create personalized video experiences through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with HeyGen
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.HEYGEN],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with HeyGen
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.HeyGen],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["HeyGen"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.HEYGEN,
auth_data={
"token": "YOUR_HEYGEN_API_KEY"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.HeyGen,
authData: {
token: "YOUR_HEYGEN_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "HeyGen",
"authData": {
"token": "YOUR_HEYGEN_API_KEY"
}
}'
```
š **Your HeyGen MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select HeyGen from the list of available integrations.
Enter your HeyGen API key to authenticate the connection.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/heygen
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/heygen-mcp-server:latest
# Run with API key support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/heygen-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"heygen": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for HeyGen. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# HubSpot
Source: https://www.klavis.ai/docs/mcp-server/hubspot
Connect AI agents to HubSpot for CRM management and sales automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to HubSpot to manage contacts, companies, deals, tickets, and automate CRM operations through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.HUBSPOT],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with HubSpot
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Hubspot],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["HubSpot"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.HUBSPOT])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.HubSpot]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/hubspot/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your HubSpot MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select HubSpot from the list of available integrations.
Complete the OAuth flow to connect your HubSpot account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/hubspot
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/hubspot-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/hubspot-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"hubspot": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for HubSpot. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Jira
Source: https://www.klavis.ai/docs/mcp-server/jira
Connect AI agents to Jira for project tracking and issue management
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Jira to manage issues, projects, sprints, and automate development workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.JIRA],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Jira
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Jira],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Jira"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.JIRA])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Jira]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/jira/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Jira MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Jira from the list of available integrations.
Complete the OAuth flow to connect your Jira account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/jira
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/jira-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/jira-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"jira": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Jira. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Klavis ReportGen
Source: https://www.klavis.ai/docs/mcp-server/klavis-reportgen
Connect AI agents to Klavis ReportGen for generating visually appealing web reports
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Klavis ReportGen to generate visually appealing JavaScript web reports based on search queries through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Klavis ReportGen
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.KLAVIS_REPORTGEN],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Klavis ReportGen
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.KlavisReportgen],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Klavis ReportGen"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.KLAVIS_REPORTGEN,
auth_data={
"api_key": "YOUR_KLAVIS_REPORTGEN_API_KEY"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.KlavisReportgen,
authData: {
api_key: "YOUR_KLAVIS_REPORTGEN_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Klavis ReportGen",
"authData": {
"api_key": "YOUR_KLAVIS_REPORTGEN_API_KEY"
}
}'
```
š **Your Klavis ReportGen MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Klavis ReportGen from the list of available integrations.
Enter your Klavis ReportGen API key to authenticate the connection.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/klavis_reportgen
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/klavis-reportgen-mcp-server:latest
# Run with API key support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/klavis-reportgen-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"klavis-reportgen": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Klavis ReportGen. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Klaviyo
Source: https://www.klavis.ai/docs/mcp-server/klaviyo
Connect AI agents to Klaviyo for managing marketing campaigns and customer data
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Klaviyo to manage marketing campaigns and customer data through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Klaviyo
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.KLAVIYO],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Klaviyo
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Klaviyo],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Klaviyo"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.KLAVIYO])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Klaviyo]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/klaviyo/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your Klaviyo API key from your [Klaviyo Developer Console](https://developers.klaviyo.com/).
š **Your Klaviyo MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Klaviyo from the list of available integrations.
Complete the OAuth flow to connect your Klaviyo account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/klaviyo
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/klaviyo-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/klaviyo-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_klaviyo_api_key"}' \
ghcr.io/klavis-ai/klaviyo-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"klaviyo": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Klaviyo. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Linear
Source: https://www.klavis.ai/docs/mcp-server/linear
Connect AI agents to Linear for project management and issue tracking automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Linear to manage issues, projects, teams, and automate project management workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.LINEAR],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Linear
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Linear],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Linear"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.LINEAR])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Linear]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/linear/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Linear MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Linear from the list of available integrations.
Complete the OAuth flow to connect your Linear workspace.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/linear
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/linear-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/linear-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"linear": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Linear. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# LinkedIn
Source: https://www.klavis.ai/docs/mcp-server/linkedin
Connect AI agents to LinkedIn for professional networking, content publishing, and profile management automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to LinkedIn to manage profiles, create posts, share content, and automate professional networking activities through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.LINKEDIN],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with LinkedIn
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.LinkedIn],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["LinkedIn"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.LINKEDIN])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.LinkedIn]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/linkedin/authorize?instance_id=YOUR_INSTANCE_ID"
```
You can specify custom scope and redirect\_url parameters in the OAuth URL. Check the API reference for more details.
Your LinkedIn MCP Server is ready! Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select LinkedIn from the list of available integrations.
Complete the OAuth flow to connect your LinkedIn account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/linkedin
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/linkedin-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/linkedin-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"linkedin": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for LinkedIn. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Markdown2doc
Source: https://www.klavis.ai/docs/mcp-server/markdown2doc
Connect AI agents to Markdown2doc for converting markdown to various document formats
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Markdown2doc to convert markdown text to different file formats (PDF, DOCX, DOC, HTML, HTML5) through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Markdown2doc
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.MARKDOWN2DOC],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Markdown2doc
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Markdown2doc],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Markdown2doc"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
š **Your Markdown2doc MCP Server is ready!** You can now use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Markdown2doc from the list of available integrations.
Enter your Markdown2doc API key to authenticate the connection.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/markdown2doc
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/markdown2doc-mcp-server:latest
# Run with API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"api_key":"your_markdown2doc_api_key"}' \
ghcr.io/klavis-ai/markdown2doc-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"markdown2doc": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Markdown2doc. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Mem0
Source: https://www.klavis.ai/docs/mcp-server/mem0
Connect AI agents to Mem0 for long-term memory, retrieval, and personalization
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect AI agents to Mem0 for long-term memory, retrieval, and personalization
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Mem0
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.MEM0],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Mem0
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Mem0],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Mem0"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.MEM0])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Mem0]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/mem0/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your Mem0 API key from your [Mem0 Developer Console](https://mem0.ai/).
š **Your Mem0 MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Mem0 from the list of available integrations.
Complete the OAuth flow to connect your Mem0 account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/mem0
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/mem0-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/mem0-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_mem0_api_key"}' \
ghcr.io/klavis-ai/mem0-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"mem0": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Mem0. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Metabase
Source: https://www.klavis.ai/docs/mcp-server/metabase
Connect AI agents to Metabase for managing data and analytics
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Metabase to manage data and analytics through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Metabase
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.METABASE],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Metabase
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Metabase],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Metabase"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.METABASE])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Metabase]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/metabase/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your Metabase API key from your [Metabase Developer Console](https://www.metabase.com/docs/latest/developers-guide/start).
š **Your Metabase MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Metabase from the list of available integrations.
Complete the OAuth flow to connect your Metabase account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/metabase
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/metabase-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/metabase-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_metabase_api_key"}' \
ghcr.io/klavis-ai/metabase-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"metabase": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Metabase. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Microsoft Teams
Source: https://www.klavis.ai/docs/mcp-server/microsoft_teams
Connect AI agents to Microsoft Teams for team collaboration and communication automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Microsoft Teams to manage teams, channels, messages, and automate collaboration workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Microsoft Teams MCP server instance
teams_server = klavis_client.mcp_server.create_server_instance(
server_name=McpServerName.MICROSOFT_TEAMS,
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Microsoft Teams MCP server instance
const teamsServer = await klavis.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.MicrosoftTeams,
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/instance/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"serverName": "Microsoft Teams",
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
**Response Information**: The API returns:
* `serverUrl`: The URL for connecting your MCP client to Microsoft Teams
* `instanceId`: Unique identifier for your server instance
* `oauthUrl`: OAuth authorization URL for Microsoft Teams authentication
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(teams_server.oauth_url)
```
```typescript TypeScript theme={null}
// Redirect user to OAuth authorization
window.location.href = teamsServer.oauthUrl;
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/microsoft_teams/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Microsoft Teams MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Microsoft Teams from the list of available integrations.
Complete the OAuth flow to connect your Microsoft account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/microsoft_teams
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/microsoft-teams-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/microsoft-teams-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"microsoft_teams": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Microsoft Teams. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Mixpanel
Source: https://www.klavis.ai/docs/mcp-server/mixpanel
Connect AI agents to Mixpanel for advanced analytics and user behavior tracking
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Mixpanel to track events, analyze user behavior, and generate insights from your product analytics through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Mixpanel
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.MIXPANEL],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Mixpanel
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Mixpanel],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Mixpanel"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.MIXPANEL,
auth_data={
"data": {
"serviceaccount_username": "YOUR_MIXPANEL_SERVICE_ACCOUNT_USERNAME",
"serviceaccount_secret": "YOUR_MIXPANEL_SERVICE_ACCOUNT_SECRET"
}
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Mixpanel,
authData: {
data: {
serviceaccount_username: "YOUR_MIXPANEL_SERVICE_ACCOUNT_USERNAME",
serviceaccount_secret: "YOUR_MIXPANEL_SERVICE_ACCOUNT_SECRET"
}
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Mixpanel",
"authData": {
"data": {
"serviceaccount_username": "YOUR_MIXPANEL_SERVICE_ACCOUNT_USERNAME",
"serviceaccount_secret": "YOUR_MIXPANEL_SERVICE_ACCOUNT_SECRET"
}
}
}'
```
Get your Mixpanel service account credentials from your [Mixpanel project settings](https://mixpanel.com/settings/project/). These credentials are required to access your analytics data.
š **Your Mixpanel MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Mixpanel from the list of available integrations.
Complete the authentication flow to connect your Mixpanel service account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/mixpanel
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/mixpanel-mcp-server:latest
# Run with Mixpanel service account credentials
docker run -p 5000:5000 \
-e AUTH_DATA='{"data":{"serviceaccount_username":"your_username","serviceaccount_secret":"your_secret"}}' \
ghcr.io/klavis-ai/mixpanel-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"mixpanel": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Mixpanel. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Monday.com
Source: https://www.klavis.ai/docs/mcp-server/monday
Connect AI agents to Monday.com for project management and workflow automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Monday.com to manage projects, track tasks, and automate workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.MONDAY],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Monday.com
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Monday],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Monday"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.MONDAY])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Monday]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/monday/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Monday.com MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Monday.com from the list of available integrations.
Complete the OAuth flow to connect your Monday.com account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/monday
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/monday-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/monday-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_monday_api_token"}' \
ghcr.io/klavis-ai/monday-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"monday": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Monday.com. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Moneybird
Source: https://www.klavis.ai/docs/mcp-server/moneybird
Connect AI agents to Moneybird for accounting and financial management
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Moneybird to manage accounting data, contacts, invoices, and financial records through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Moneybird
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.MONEYBIRD],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Moneybird
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Moneybird],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Moneybird"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.MONEYBIRD,
auth_data={
"token": "YOUR_MONEYBIRD_API_TOKEN"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Moneybird,
authData: {
token: "YOUR_MONEYBIRD_API_TOKEN"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Moneybird",
"authData": {
"token": "YOUR_MONEYBIRD_API_TOKEN"
}
}'
```
š **Your Moneybird MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Moneybird from the list of available integrations.
Enter your Moneybird API token to authenticate the connection.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/moneybird
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/moneybird-mcp-server:latest
# Run with API key support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/moneybird-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"moneybird": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Moneybird. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Motion
Source: https://www.klavis.ai/docs/mcp-server/motion
Connect AI agents to Motion for intelligent task management and calendar automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Motion to manage tasks, projects, workspaces, and automate scheduling workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Motion
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.MOTION],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Motion
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Motion],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Motion"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.MOTION,
auth_data={
"api_key": "YOUR_MOTION_API_KEY"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Motion,
authData: {
api_key: "YOUR_MOTION_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Motion",
"authData": {
"api_key": "YOUR_MOTION_API_KEY"
}
}'
```
š **Your Motion MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Motion from the list of available integrations.
Enter your Motion API key to connect.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/motion
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/motion-mcp-server:latest
# Run with API key support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/motion-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"motion": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Motion. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Notion
Source: https://www.klavis.ai/docs/mcp-server/notion
Connect AI agents to Notion for knowledge management and collaborative workflows
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Notion to manage pages, databases, and content, enabling AI agents to create, update, and search your workspace.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.NOTION],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Notion
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Notion],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Notion"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.NOTION])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Notion]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/notion/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Notion MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Notion from the list of available integrations.
Complete the OAuth flow to connect your Notion workspace.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/notion
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/notion-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/notion-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_notion_token"}' \
ghcr.io/klavis-ai/notion-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"notion": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Watch the Example
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Notion. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# OneDrive
Source: https://www.klavis.ai/docs/mcp-server/onedrive
Connect AI agents to OneDrive for cloud storage management and file automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to OneDrive to manage files, folders, and automate cloud storage operations through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.ONEDRIVE],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a OneDrive MCP server instance
const onedriveServer = await klavis.mcpServer.createServerInstance({
serverName: Klavis.McpServerName.Onedrive,
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["OneDrive"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.ONEDRIVE])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.OneDrive]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/onedrive/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your OneDrive MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select OneDrive from the list of available integrations.
Complete the OAuth flow to connect your Microsoft account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/onedrive
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/onedrive-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/onedrive-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"onedrive": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for OneDrive. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# OpenRouter
Source: https://www.klavis.ai/docs/mcp-server/openrouter
Connect AI agents to OpenRouter for access to multiple AI models and model comparison
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to OpenRouter to access multiple AI models, compare model performance, and manage usage across different AI providers through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with OpenRouter
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.OPENROUTER],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with OpenRouter
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.OpenRouter],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["OpenRouter"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
You can get your OpenRouter API key from the [OpenRouter website](https://openrouter.ai/keys).
```python Python theme={null}
# Set the OpenRouter API key for your instance
response = klavis_client.mcp_server.set_instance_auth(
instance_id=openrouter_server.instance_id,
auth_data={
"api_key": "YOUR_OPENROUTER_API_KEY"
}
)
```
```typescript TypeScript theme={null}
// Set the OpenRouter API key for your instance
const response = await klavis.mcpServer.setInstanceAuth({
instanceId: openrouterServer.instanceId,
authData: {
api_key: "YOUR_OPENROUTER_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/instance/set-auth" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"instanceId": "YOUR_INSTANCE_ID",
"authData": {
"api_key": "YOUR_OPENROUTER_API_KEY"
}
}'
```
š **Your OpenRouter MCP Server is ready!** You can now use your MCP server URL with any MCP-compatible client to access multiple AI models.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select OpenRouter from the list of available integrations.
Enter your OpenRouter API key to enable multi-model access.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/openrouter
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/openrouter-mcp-server:latest
# Run with OpenRouter API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"api_key":"your_openrouter_api_key"}' \
ghcr.io/klavis-ai/openrouter-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"openrouter": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for OpenRouter. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Outlook
Source: https://www.klavis.ai/docs/mcp-server/outlook
Connect AI agents to Outlook for email management and automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Outlook to read, send, organize emails, and automate email workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.OUTLOOK],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Outlook
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Outlook],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Outlook"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.OUTLOOK])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Outlook]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/outlook/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Outlook MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Outlook from the list of available integrations.
Complete the OAuth flow to connect your Microsoft account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/outlook
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/outlook-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/outlook-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"outlook": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Outlook. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# MCP Servers Overview
Source: https://www.klavis.ai/docs/mcp-server/overview
Quickstart to Klavis-hosted MCP servers and available integrations.
Learn how to easily integrate with Klavis remote hosted MCP Servers.
{"Affinity icon"}
}
href="/mcp-server/affinity"
/>
}
href="/mcp-server/airtable"
/>
}
href="/mcp-server/asana"
/>
}
href="/mcp-server/attio"
/>
}
href="/mcp-server/brave_search"
/>
{"Calendly icon"}
}
href="/mcp-server/calendly"
/>
}
href="/mcp-server/clickup"
/>
}
href="/mcp-server/close"
/>
{"Coinbase icon"}
}
href="/mcp-server/coinbase"
/>
}
href="/mcp-server/confluence"
/>
{"\uD83D\uDD25"}
}
href="/mcp-server/firecrawl-deep-research"
/>
}
href="/mcp-server/discord"
/>
}
href="/mcp-server/doc2markdown"
/>
}
href="/mcp-server/dropbox"
/>
}
href="/mcp-server/github"
/>
}
href="/mcp-server/gmail"
/>
}
href="/mcp-server/gong"
/>
}
href="/mcp-server/google_calendar"
/>
{"Google Docs icon"}
}
href="/mcp-server/google_docs"
/>
}
href="/mcp-server/google_drive"
/>
}
href="/mcp-server/google_sheets"
/>
}
href="/mcp-server/hubspot"
/>
}
href="/mcp-server/jira"
/>
}
href="/mcp-server/klavis-reportgen"
/>
}
href="/mcp-server/linear"
/>
}
href="/mcp-server/linkedin"
/>
}
href="/mcp-server/microsoft_teams"
/>
}
href="/mcp-server/mixpanel"
/>
}
href="/mcp-server/monday"
/>
}
href="/mcp-server/motion"
/>
}
href="/mcp-server/notion"
/>
OfficeCore10_32x_24x_20x_16x_01-22-2019
}
href="/mcp-server/onedrive"
/>
}
href="/mcp-server/outlook"
/>
}
href="/mcp-server/perplexity"
/>
}
href="/mcp-server/postgres"
/>
}
href="/mcp-server/quickbooks"
/>
}
href="/mcp-server/resend"
/>
}
href="/mcp-server/slack"
/>
}
href="/mcp-server/stripe"
/>
{"Supabase icon"}
}
href="/mcp-server/supabase"
/>
}
href="/mcp-server/wordpress"
/>
}
href="/mcp-server/youtube"
/>
}
href="/mcp-server/zendesk"
/>
{"Affinity icon"}
}
href="/mcp-server/affinity"
/>
}
href="/mcp-server/attio"
/>
}
href="/mcp-server/close"
/>
}
href="/mcp-server/hubspot"
/>
}
href="/mcp-server/asana"
/>
}
href="/mcp-server/clickup"
/>
}
href="/mcp-server/jira"
/>
}
href="/mcp-server/linear"
/>
}
href="/mcp-server/monday"
/>
}
href="/mcp-server/confluence"
/>
}
href="/mcp-server/dropbox"
/>
}
href="/mcp-server/gmail"
/>
}
href="/mcp-server/google_calendar"
/>
{"Google Docs icon"}
}
href="/mcp-server/google_docs"
/>
}
href="/mcp-server/google_drive"
/>
}
href="/mcp-server/google_sheets"
/>
}
href="/mcp-server/microsoft_teams"
/>
}
href="/mcp-server/notion"
/>
OfficeCore10_32x_24x_20x_16x_01-22-2019
}
href="/mcp-server/onedrive"
/>
}
href="/mcp-server/outlook"
/>
}
href="/mcp-server/slack"
/>
}
href="/mcp-server/wordpress"
/>
}
href="/mcp-server/github"
/>
}
href="/mcp-server/postgres"
/>
{"Supabase icon"}
}
href="/mcp-server/supabase"
/>
{"Calendly icon"}
}
href="/mcp-server/calendly"
/>
}
href="/mcp-server/google_calendar"
/>
}
href="/mcp-server/airtable"
/>
}
href="/mcp-server/klavis-reportgen"
/>
}
href="/mcp-server/mixpanel"
/>
}
href="/mcp-server/motion"
/>
}
href="/mcp-server/zendesk"
/>
}
href="/mcp-server/brave_search"
/>
{"\uD83D\uDD25"}
}
href="/mcp-server/firecrawl-deep-research"
/>
}
href="/mcp-server/perplexity"
/>
}
href="/mcp-server/discord"
/>
}
href="/mcp-server/linkedin"
/>
}
href="/mcp-server/resend"
/>
}
href="/mcp-server/youtube"
/>
}
href="/mcp-server/doc2markdown"
/>
}
href="/mcp-server/stripe"
/>
{"Coinbase icon"}
}
href="/mcp-server/coinbase"
/>
}
href="/mcp-server/quickbooks"
/>
# Pagerduty
Source: https://www.klavis.ai/docs/mcp-server/pagerduty
Connect AI agents to Pagerduty for managing incidents and alerts
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Pagerduty to manage incidents and alerts through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Pagerduty
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.PAGERDUTY],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Pagerduty
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Pagerduty],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Pagerduty"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.PAGERDUTY])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Pagerduty]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/pagerduty/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your Pagerduty API key from your [Pagerduty Developer Console](https://developer.pagerduty.com/).
š **Your Pagerduty MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Pagerduty from the list of available integrations.
Complete the OAuth flow to connect your Pagerduty account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/pagerduty
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/pagerduty-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/pagerduty-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_pagerduty_api_key"}' \
ghcr.io/klavis-ai/pagerduty-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"pagerduty": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Pagerduty. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Perplexity
Source: https://www.klavis.ai/docs/mcp-server/perplexity
Learn how to use Klavis to connect your AI application to Perplexity MCP Server
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Perplexity to leverage AI-powered search capabilities and advanced research functionality through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Perplexity
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.PERPLEXITY],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Perplexity
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Perplexity],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Perplexity"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.PERPLEXITY,
auth_data={
"api_key": "YOUR_PERPLEXITY_API_KEY"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Perplexity,
authData: {
api_key: "YOUR_PERPLEXITY_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Perplexity",
"authData": {
"api_key": "YOUR_PERPLEXITY_API_KEY"
}
}'
```
š **Your Perplexity MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Perplexity from the list of available integrations.
Enter your Perplexity API key to authenticate the connection.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/perplexity
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/perplexity-mcp-server:latest
# Run with API key support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/perplexity-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"perplexity": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Perplexity. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Pipedrive
Source: https://www.klavis.ai/docs/mcp-server/pipedrive
Connect AI agents to Pipedrive for managing sales and CRM
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Pipedrive to manage sales and CRM through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Pipedrive
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.PIPEDRIVE],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Pipedrive
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Pipedrive],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Pipedrive"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.PIPEDRIVE])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Pipedrive]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/pipedrive/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your Pipedrive API key from your [Pipedrive Developer Console](https://developers.pipedrive.com/).
š **Your Pipedrive MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Pipedrive from the list of available integrations.
Complete the OAuth flow to connect your Pipedrive account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/pipedrive
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/pipedrive-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/pipedrive-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_pipedrive_api_key"}' \
ghcr.io/klavis-ai/pipedrive-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"pipedrive": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Pipedrive. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Plai
Source: https://www.klavis.ai/docs/mcp-server/plai
Connect AI agents to Plai for Facebook, Instagram, and LinkedIn advertising
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Plai to create and manage Facebook, Instagram, and LinkedIn ad campaigns through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Plai
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.PLAI],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Plai
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Plai],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Plai"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.PLAI,
auth_data={
"api_key": "YOUR_PLAI_API_KEY"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Plai,
authData: {
api_key: "YOUR_PLAI_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Plai",
"authData": {
"api_key": "YOUR_PLAI_API_KEY"
}
}'
```
š **Your Plai MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Plai from the list of available integrations.
Enter your Plai API key to authenticate the connection.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/plai
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/plai-mcp-server:latest
# Run with API key support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/plai-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"plai": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Plai. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# PostgreSQL
Source: https://www.klavis.ai/docs/mcp-server/postgres
Connect AI agents to PostgreSQL databases for query execution, data analysis, and database management automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to PostgreSQL databases to execute queries, analyze data, manage tables, and automate database operations through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with PostgreSQL
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.POSTGRES],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
# Create a Strata MCP server with PostgreSQL
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Postgres],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Postgres"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.POSTGRES,
auth_data={
"api_key": "postgresql://username:password@host:port/database"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Postgres,
authData: {
api_key: "postgresql://username:password@host:port/database"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Postgres",
"authData": {
"api_key": "postgresql://username:password@host:port/database"
}
}'
```
Use the standard PostgreSQL connection string format: `postgresql://username:password@host:port/database`
š **Your PostgreSQL MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select PostgreSQL from the list of available integrations.
Enter your PostgreSQL connection string in the configuration form.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/postgres
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/postgres-mcp-server:latest
# Run with connection string
docker run -p 5000:5000 \
-e POSTGRES_CONNECTION_STRING="postgresql://username:password@host:port/database" \
ghcr.io/klavis-ai/postgres-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"postgres": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for PostgreSQL. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Posthog
Source: https://www.klavis.ai/docs/mcp-server/posthog
Connect AI agents to Posthog for managing analytics and collaboration
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Posthog to manage analytics and collaboration through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Posthog
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.POSTHOG],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Posthog
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Posthog],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Posthog"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.POSTHOG])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Posthog]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/posthog/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your Posthog API key from your [Posthog Developer Console](https://posthog.com/docs).
š **Your Posthog MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Posthog from the list of available integrations.
Complete the OAuth flow to connect your Posthog account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/posthog
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/posthog-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/posthog-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_posthog_api_key"}' \
ghcr.io/klavis-ai/posthog-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"posthog": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Posthog. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# QuickBooks
Source: https://www.klavis.ai/docs/mcp-server/quickbooks
Connect AI agents to QuickBooks for accounting automation and financial data management
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to QuickBooks to manage accounts, invoices, customers, payments, vendors, and automate accounting workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.QUICKBOOKS],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with QuickBooks
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.QuickBooks],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["QuickBooks"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.QUICKBOOKS])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.QuickBooks]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/quickbooks/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your QuickBooks MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select QuickBooks from the list of available integrations.
Complete the OAuth flow to connect your QuickBooks company.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/quickbooks
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/quickbooks-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/quickbooks-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"quickbooks": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for QuickBooks. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Resend
Source: https://www.klavis.ai/docs/mcp-server/resend
Connect AI agents to Resend for automated email campaigns and transactional messaging
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Resend to send emails, manage audiences, create broadcasts, and automate email marketing through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Resend
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.RESEND],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Resend
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Resend],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Resend"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.RESEND,
auth_data={
"api_key": "YOUR_RESEND_API_KEY"
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Resend,
authData: {
api_key: "YOUR_RESEND_API_KEY"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Resend",
"authData": {
"api_key": "YOUR_RESEND_API_KEY"
}
}'
```
š **Your Resend MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Resend from the list of available integrations.
Enter your Resend API key to connect.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/resend
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/resend-mcp-server:latest
# Run with API key support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/resend-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"resend": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Resend. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Salesforce
Source: https://www.klavis.ai/docs/mcp-server/salesforce
Connect AI agents to Salesforce for CRM and sales automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Salesforce to manage leads, opportunities, accounts, contacts, and automate sales processes through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.SALESFORCE],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Salesforce
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Salesforce],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Salesforce"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.SALESFORCE])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Salesforce]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/salesforce/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Salesforce MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Salesforce from the list of available integrations.
Complete the OAuth flow to connect your Salesforce account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/salesforce
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/salesforce-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/salesforce-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"salesforce": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Salesforce. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Sendgrid
Source: https://www.klavis.ai/docs/mcp-server/sendgrid
Connect AI agents to Sendgrid for managing emails and collaboration
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Sendgrid to manage emails and collaboration through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Sendgrid
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.SENDGRID],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Sendgrid
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Sendgrid],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Sendgrid"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.SENDGRID])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Sendgrid]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/sendgrid/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your Sendgrid API key from your [Sendgrid Developer Console](https://sendgrid.com/en-us/solutions/email-api).
š **Your Sendgrid MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Sendgrid from the list of available integrations.
Complete the OAuth flow to connect your Sendgrid account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/sendgrid
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/sendgrid-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/sendgrid-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_sendgrid_api_key"}' \
ghcr.io/klavis-ai/sendgrid-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"sendgrid": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Sendgrid. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# ServiceNow
Source: https://www.klavis.ai/docs/mcp-server/servicenow
Connect ServiceNow to manage IT service workflows through AI agents.
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to ServiceNow for a central database and application suite to build custom workflows, automate routine work, and manage service requests for various business functions with AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with ServiceNow
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.SERVICENOW],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with ServiceNow
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.ServiceNow],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["ServiceNow"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.SERVICENOW,
auth_data={
data={
"instance": "YOUR_SERVICENOW_INSTANCE",
"username": "YOUR_SERVICENOW_USERNAME",
"password": "YOUR_SERVICENOW_PASSWORD"
}
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Cloudflare,
authData: {
data: {
instance: "YOUR_SERVICENOW_INSTANCE",
username: "YOUR_SERVICENOW_USERNAME",
password: "YOUR_SERVICENOW_PASSWORD"
}
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "ServiceNow",
"authData": {
"data": {
"instance": "YOUR_SERVICENOW_INSTANCE",
"username": "YOUR_SERVICENOW_USERNAME",
"password": "YOUR_SERVICENOW_PASSWORD"
}
}
}'
```
š **Your ServiceNow MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select ServiceNow from the list of available integrations.
Enter your ServiceNow instance name, user name and password to authenticate the connection.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for ServiceNow. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Shopify
Source: https://www.klavis.ai/docs/mcp-server/shopify
Connect AI agents to Shopify for managing e-commerce and collaboration
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Shopify to manage e-commerce and collaboration through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Shopify
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.SHOPIFY],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Shopify
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Shopify],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Shopify"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
klavis_client.mcp_server.set_strata_auth(
strata_id=response.strata_id,
server_name=McpServerName.SHOPIFY,
auth_data={
"data": {
"access_token": "YOUR_SHOPIFY_ACCESS_TOKEN",
"shop_domain": "YOUR_SHOP_DOMAIN"
}
}
)
```
```typescript TypeScript theme={null}
await klavis.mcpServer.setStrataAuth({
strataId: response.strataId,
serverName: Klavis.McpServerName.Shopify,
authData: {
data: {
access_token: "YOUR_SHOPIFY_ACCESS_TOKEN",
shop_domain: "YOUR_SHOP_DOMAIN"
}
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"strataId": "YOUR_STRATA_ID",
"serverName": "Shopify",
"authData": {
"data": {
"access_token": "YOUR_SHOPIFY_ACCESS_TOKEN",
"shop_domain": "YOUR_SHOP_DOMAIN"
}
}
}'
```
Get your Shopify access token from your [Shopify Admin API settings](https://shopify.dev/docs/api/admin-rest). The shop domain should be in the format `your-store.myshopify.com`.
š **Your Shopify MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Shopify from the list of available integrations.
Complete the OAuth flow to connect your Shopify account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/shopify
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/shopify-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/shopify-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_shopify_api_key"}' \
ghcr.io/klavis-ai/shopify-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"shopify": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Shopify. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Slack
Source: https://www.klavis.ai/docs/mcp-server/slack
Connect AI agents to Slack for team communication and collaboration
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Slack to manage team communication, automate workflows, and collaborate through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.SLACK],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Slack
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Slack],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Slack"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.SLACK])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Slack]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/slack/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Slack MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Slack from the list of available integrations.
Complete the OAuth flow to connect your Slack workspace.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/slack
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/slack-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/slack-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"bot_token":"your_slack_bot_token"}' \
ghcr.io/klavis-ai/slack-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"slack": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Slack. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Stripe
Source: https://www.klavis.ai/docs/mcp-server/stripe
Connect AI agents to Stripe for payment processing, customer management, and subscription automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Stripe to manage payments, customers, subscriptions, and automate payment processing workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.STRIPE],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Stripe
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Stripe],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Stripe"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
# Configure your Stripe API key in the Klavis dashboard or via API
# Get your Stripe secret key from https://dashboard.stripe.com/apikeys
stripe_api_key = "sk_test_your_stripe_secret_key_here"
```
```typescript TypeScript theme={null}
// Configure your Stripe API key in the Klavis dashboard or via API
// Get your Stripe secret key from https://dashboard.stripe.com/apikeys
const stripeApiKey = "sk_test_your_stripe_secret_key_here";
```
```bash cURL theme={null}
# Configure your Stripe API key in the Klavis dashboard
# Get your Stripe secret key from https://dashboard.stripe.com/apikeys
echo "Configure your API key at: https://www.klavis.ai/home/mcp-servers"
```
Get your Stripe secret key from your [Stripe Dashboard](https://dashboard.stripe.com/apikeys). Use test keys for development.
š **Your Stripe MCP Server is ready!** Once the API key is configured, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Stripe from the list of available integrations.
Enter your Stripe secret API key in the configuration form.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/stripe
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/stripe-mcp-server:latest
# Run with API key
docker run -p 5000:5000 \
-e STRIPE_API_KEY="sk_test_your_stripe_secret_key_here" \
ghcr.io/klavis-ai/stripe-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"stripe": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Watch the Example
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Stripe. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Supabase
Source: https://www.klavis.ai/docs/mcp-server/supabase
Connect AI agents to Supabase for database management, project creation, and serverless backend automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Supabase to manage database projects, execute SQL queries, handle migrations, and automate backend development workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.SUPABASE],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Supabase
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Supabase],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Supabase"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.SUPABASE])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Supabase]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/supabase/authorize?instance_id=YOUR_INSTANCE_ID"
```
```python Python theme={null}
from klavis import Klavis
klavis_client = Klavis(api_key="YOUR_KLAVIS_API_KEY")
# Set the Supabase access token
response = klavis_client.mcp_server.set_instance_auth(
instance_id="YOUR_INSTANCE_ID",
auth_data={
"token": "YOUR_SUPABASE_ACCESS_TOKEN"
}
)
```
```typescript TypeScript theme={null}
import { KlavisClient } from 'klavis';
const klavis = new KlavisClient({ apiKey: 'YOUR_KLAVIS_API_KEY' });
// Set the Supabase access token
const response = await klavis.mcpServer.setInstanceAuth({
instanceId: "YOUR_INSTANCE_ID",
authData: {
token: "YOUR_SUPABASE_ACCESS_TOKEN"
}
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/instance/set-auth" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"instanceId": "YOUR_INSTANCE_ID",
"authData": {
"token": "YOUR_SUPABASE_ACCESS_TOKEN"
}
}'
```
Get your Supabase access token from [Supabase Dashboard Account Tokens](https://supabase.com/dashboard/account/tokens).
Your Supabase MCP Server is ready! Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Supabase from the list of available integrations.
Complete the OAuth flow to connect your Supabase account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/supabase
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/supabase-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/supabase-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"supabase": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
### Video Tutorial
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Supabase. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Tavily
Source: https://www.klavis.ai/docs/mcp-server/tavily
Connect AI agents to Tavily for managing files and collaboration
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Tavily to manage files and collaboration through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Tavily
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.TAVILY],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Tavily
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Tavily],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Tavily"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.TAVILY])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Tavily]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/tavily/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your Tavily API key from your [Tavily Developer Console](https://docs.tavily.com/welcome).
š **Your Tavily MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Tavily from the list of available integrations.
Complete the OAuth flow to connect your Tavily account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/tavily
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/tavily-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/tavily-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_tavily_api_key"}' \
ghcr.io/klavis-ai/tavily-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"tavily": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Tavily. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Vercel
Source: https://www.klavis.ai/docs/mcp-server/vercel
Connect AI agents to Vercel for managing deployments and collaboration
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Box to manage files and collaboration through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with Vercel
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.VERCEL],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Vercel
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Vercel],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Vercel"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.VERCEL])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Vercel]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/vercel/authorize?instance_id=YOUR_INSTANCE_ID"
```
Get your Vercel API key from your [Vercel Dashboard](https://vercel.com/dashboard).
š **Your Vercel MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Vercel from the list of available integrations.
Complete the OAuth flow to connect your Vercel account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/vercel
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/vercel-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/vercel-mcp-server:latest
# Or run with manual API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_vercel_api_key"}' \
ghcr.io/klavis-ai/vercel-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"vercel": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Vercel. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# WhatsApp
Source: https://www.klavis.ai/docs/mcp-server/whatsapp
Connect AI agents to WhatsApp for business messaging and communication
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to WhatsApp to send messages and manage conversations through the WhatsApp Business API via AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with WhatsApp
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.WHATSAPP],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with WhatsApp
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.WhatsApp],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["WhatsApp"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
š **Your WhatsApp MCP Server is ready!** You can now use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select WhatsApp from the list of available integrations.
Enter your WhatsApp Business API key to authenticate the connection.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/whatsapp
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/whatsapp-mcp-server:latest
# Run with WhatsApp API key
docker run -p 5000:5000 \
-e AUTH_DATA='{"token":"your_whatsapp_api_key"}' \
ghcr.io/klavis-ai/whatsapp-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"whatsapp": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for WhatsApp. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# WordPress
Source: https://www.klavis.ai/docs/mcp-server/wordpress
Connect AI agents to WordPress for content management, post creation, and blog automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to WordPress.com to manage posts, pages, sites, and automate content publishing workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.WORDPRESS],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with WordPress
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.WordPress],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["WordPress"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.WORDPRESS])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.WordPress]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/wordpress/authorize?instance_id=YOUR_INSTANCE_ID"
```
Your WordPress MCP Server is ready! Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select WordPress from the list of available integrations.
Complete the OAuth flow to connect your WordPress.com account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/wordpress
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/wordpress-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/wordpress-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"wordpress": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
### Video Tutorial
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for WordPress. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# YouTube
Source: https://www.klavis.ai/docs/mcp-server/youtube
Connect AI agents to YouTube for video transcript extraction, content analysis, and YouTube data automation
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to YouTube to extract video transcripts, analyze content, and automate video data processing workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
# Create a Strata MCP server with YouTube
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.YOUTUBE],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with YouTube
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.YouTube],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["YouTube"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
š **Your YouTube MCP Server is ready!** You can now use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select YouTube from the list of available integrations.
No authentication required - your server is immediately ready.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/youtube
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/youtube-mcp-server:latest
# Run the server
docker run -p 5000:5000 \
ghcr.io/klavis-ai/youtube-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"youtube": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for YouTube. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
Customize OAuth flows with your own branding
# Zendesk
Source: https://www.klavis.ai/docs/mcp-server/zendesk
Connect AI agents to Zendesk for customer support and ticket management
**Prerequisites**
Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get your API Key.
## Getting started
Connect to Zendesk to manage customer support tickets, handle inquiries, and streamline support workflows through AI agents.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
servers=[McpServerName.ZENDESK],
user_id="user123"
)
```
```typescript TypeScript theme={null}
import { KlavisClient, Klavis } from 'klavis';
const klavis = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY! });
// Create a Strata MCP server with Zendesk
const response = await klavis.mcpServer.createStrataServer({
servers: [Klavis.McpServerName.Zendesk],
userId: "user123"
});
```
```bash cURL theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"servers": ["Zendesk"],
"userId": "user123"
}'
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
Full Strata API endpoints
```python Python theme={null}
import webbrowser
# Open OAuth authorization page
webbrowser.open(response.oauth_urls[McpServerName.ZENDESK])
```
```typescript TypeScript theme={null}
import open from 'open';
// Open OAuth authorization page
await open(response.oauthUrls[Klavis.McpServerName.Zendesk]);
```
```bash cURL theme={null}
# Copy and paste the OAuth URL into your browser
echo "Visit this URL to authorize: https://api.klavis.ai/oauth/zendesk/authorize?instance_id=YOUR_INSTANCE_ID"
```
š **Your Zendesk MCP Server is ready!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
Go to your [Dashboard](https://www.klavis.ai/home/mcp-servers).
Select Zendesk from the list of available integrations.
Complete the OAuth flow to connect your Zendesk account.
Copy the MCP endpoint URL and add it to your MCP-supported client (Claude Desktop, Cursor, VS Code, etc.).
```bash theme={null}
git clone https://github.com/klavis-ai/klavis
cd klavis/mcp_servers/zendesk
```
```bash theme={null}
# Pull the Docker image
docker pull ghcr.io/klavis-ai/zendesk-mcp-server:latest
# Run with OAuth support (requires Klavis API key)
docker run -p 5000:5000 \
-e KLAVIS_API_KEY=$KLAVIS_API_KEY \
ghcr.io/klavis-ai/zendesk-mcp-server:latest
# Or run with manual OAuth token
docker run -p 5000:5000 \
-e AUTH_DATA='{"access_token":"your_zendesk_oauth_token"}' \
ghcr.io/klavis-ai/zendesk-mcp-server:latest
```
```json theme={null}
{
"mcpServers": {
"zendesk": {
"url": "http://localhost:5000/mcp/"
}
}
}
```
## Available Tools
With our progressive discovery approach, Klavis System is capable of enabling all tools for Zendesk. Please use the [get\_tools](https://www.klavis.ai/docs/api-reference/mcp-server/get-tools) API for more details. If you find any tool that is missing, please reach out to [contact@klavis.ai](mailto:contact@klavis.ai).
## Next Steps
Customize OAuth flows with your own branding
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
REST endpoints and schemas
# Quickstart
Source: https://www.klavis.ai/docs/quickstart
Let your agent connect any tools reliably in minutes via MCP
**Prerequisites** Before you begin, [create an account](https://www.klavis.ai/home/api-keys) and get the API Key.
## Strata
One MCP server that lets AI agents handle any tools progressively.
Go to your Dashboard.
Klavis enables all integrations for you by default. Click the ellipsis button if you want to disable a specific integration.
Complete authentication by clicking the "Authorize" button. You can also skip this step since we have an authentication handler tool that will prompt to authenticate when needed.
Add to your favorite MCP-supported clients, such as Cursor, Claude Code, VS Code, ChatGPT, etc.
```bash pip theme={null}
pip install klavis
```
```bash npm theme={null}
npm install klavis
```
`userId` specifies whose connected accounts and data you are accessing in Klavis. It should be a unique id for yourself, your team, or your organization.
```bash Curl theme={null}
curl -X POST "https://api.klavis.ai/mcp-server/strata/create" \
-H "Authorization: Bearer YOUR_KLAVIS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"userId": "user123",
"servers": ["Gmail", "YouTube"]
}'
```
```python Python theme={null}
from klavis import Klavis
from klavis.types import McpServerName
klavis_client = Klavis(api_key="YOUR_KLAVIS_API_KEY")
response = klavis_client.mcp_server.create_strata_server(
user_id="user123",
servers=[McpServerName.GMAIL, McpServerName.YOUTUBE],
)
```
```typescript TypeScript theme={null}
import { Klavis } from 'klavis';
const klavis = new Klavis.Client({ apiKey: 'YOUR_KLAVIS_API_KEY' });
const strata = await klavis.strata.create({
userId: 'user123',
servers: ['GMAIL', 'YOUTUBE'],
});
```
**Response Information**: The API returns:
* `strataServerUrl`: The URL you'll use to connect your MCP client to the Strata MCP Server
* `oauthUrls`: Authorization links for services that require OAuth authentication
* `apiKeyUrls`: Links to configure API keys for services that use API key authentication
Full Strata API endpoints
```bash Curl theme={null}
Copy and paste the OAuth URL into your web browser
```
```python Python theme={null}
import webbrowser
# Handle OAuth authorization if needed
if response.oauth_urls:
for server_name, oauth_url in response.oauth_urls.items():
webbrowser.open(oauth_url)
input(f"Press Enter after completing {server_name} OAuth authorization...")
```
```typescript TypeScript theme={null}
// Handle OAuth authorization if needed
if (response.oauthUrls) {
for (const [serverName, oauthUrl] of Object.entries(response.oauthUrls)) {
if (typeof window !== 'undefined') {
window.open(oauthUrl);
}
console.log(`Please complete ${serverName} OAuth authorization at: ${oauthUrl}`);
// In a real application, you'd wait for OAuth completion via callback
await new Promise(resolve => {
console.log(`Press any key after completing ${serverName} OAuth authorization...`);
// This would be replaced with proper OAuth flow handling
resolve(null);
});
}
}
```
**Authentication Methods**:
* **API Key**: See [API Key authentication guide](/auth/api-key) for details.
* **OAuth**: See [OAuth authentication guide](/auth/oauth) for details.
š **Your MCP Server URL is ready to use!** Once authentication is complete, you can use your MCP server URL with any MCP-compatible client.
```python Python theme={null}
import os
import asyncio
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
from langchain_openai import ChatOpenAI
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from dotenv import load_dotenv
load_dotenv()
async def main():
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
# Step 1: Create a Strata MCP server with Gmail and YouTube integrations
response = klavis_client.mcp_server.create_strata_server(
user_id="demo_user",
servers=[McpServerName.GMAIL, McpServerName.YOUTUBE],
)
# Step 2: Handle OAuth authorization if needed
if response.oauth_urls:
for server_name, oauth_url in response.oauth_urls.items():
webbrowser.open(oauth_url)
input(f"Press Enter after completing {server_name} OAuth authorization...")
# Step 3: Create LangChain Agent with MCP Tools
mcp_client = MultiServerMCPClient({
"strata": {
"transport": "streamable_http",
"url": response.strata_server_url,
}
})
# Get all available tools from Strata
tools = await mcp_client.get_tools()
# Setup LLM
llm = ChatOpenAI(model="gpt-4o-mini", api_key=os.getenv("OPENAI_API_KEY"))
# Step 4: Create LangChain agent with MCP tools
agent = create_react_agent(
model=llm,
tools=tools,
prompt=(
"You are a helpful assistant that can use MCP tools. "
),
)
my_email = "golden-kpop@example.com" # TODO: Replace with your email
# Step 5: Invoke the agent
result = await agent.ainvoke({
"messages": [{"role": "user", "content": f"summarize this video - https://youtu.be/yebNIHKAC4A?si=1Rz_ZsiVRz0YfOR7 and send the summary to my email {my_email}"}],
})
# Print only the final AI response content
print(result["messages"][-1].content)
if __name__ == "__main__":
asyncio.run(main())
```
```python Python theme={null}
import os
import asyncio
import webbrowser
from klavis import Klavis
from klavis.types import McpServerName
from llama_index.llms.openai import OpenAI
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.tools.mcp import BasicMCPClient
from llama_index.tools.mcp import (
aget_tools_from_mcp_url,
)
from dotenv import load_dotenv
load_dotenv()
async def main():
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
# Step 1: Create a Strata MCP server with Gmail and YouTube integrations
response = klavis_client.mcp_server.create_strata_server(
user_id="1234",
servers=[McpServerName.GMAIL, McpServerName.YOUTUBE],
)
# Step 2: Handle OAuth authorization if needed
if response.oauth_urls:
for server_name, oauth_url in response.oauth_urls.items():
webbrowser.open(oauth_url)
input(f"Press Enter after completing {server_name} OAuth authorization...")
# Get all available tools from Strata
tools = await aget_tools_from_mcp_url(
response.strata_server_url,
client=BasicMCPClient(response.strata_server_url)
)
# Setup LLM
llm = OpenAI(model="gpt-4o-mini", api_key=os.getenv("OPENAI_API_KEY"))
# Step 3: Create LlamaIndex agent with MCP tools
agent = FunctionAgent(
name="my_first_agent",
description="Agent using MCP-based tools",
tools=tools,
llm=llm,
system_prompt="You are an AI assistant that uses MCP tools.",
)
my_email = "golden-kpop@example.com" # TODO: Replace with your email
youtube_video_url = "https://youtu.be/yebNIHKAC4A?si=1Rz_ZsiVRz0YfOR7" # TODO: Replace with your favorite youtube video URL
# Step 4: Invoke the agent
response = await agent.run(
f"summarize this video - {youtube_video_url} and mail this summary to my email {my_email}"
)
print(response)
if __name__ == "__main__":
asyncio.run(main())
```
Coming soon
```python Python theme={null}
import os
import asyncio
import webbrowser
from dotenv import load_dotenv
from klavis import Klavis
from klavis.types import McpServerName
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.ui import Console
from autogen_core import CancellationToken
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import StreamableHttpServerParams
from autogen_ext.tools.mcp import mcp_server_tools
load_dotenv()
async def main() -> None:
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
# Step 1: Create a Strata MCP server with Gmail and YouTube integrations
response = klavis_client.mcp_server.create_strata_server(
user_id="demo_user",
servers=[McpServerName.GMAIL, McpServerName.YOUTUBE],
)
# Handle OAuth authorization if required
if response.oauth_urls:
for server_name, oauth_url in response.oauth_urls.items():
webbrowser.open(oauth_url)
input(f"Press Enter after completing {server_name} OAuth authorization...")
server_params = StreamableHttpServerParams(
url=response.strata_server_url,
timeout=30.0,
sse_read_timeout=300.0,
terminate_on_close=True,
)
adapters = await mcp_server_tools(server_params)
model_client = OpenAIChatCompletionClient(model="gpt-4")
agent = AssistantAgent(
name="MultiAI",
model_client=model_client,
tools=adapters,
system_message="You are a helpful AI assistant.",
)
await Console(
agent.run_stream(
task="Get my latest mails.",
cancellation_token=CancellationToken(),
)
)
if __name__ == "__main__":
asyncio.run(main())
```
Visit [https://github.com/Klavis-AI/klavis](https://github.com/Klavis-AI/klavis) to view the source code and find more information
```bash pipx theme={null}
pipx install strata-mcp
```
```bash pip theme={null}
pip install strata-mcp
```
Configure your MCP servers using the CLI tool.
```bash Add Server theme={null}
strata add
```
```bash List Servers theme={null}
strata list
```
```bash Enable Server theme={null}
strata enable
```
Start the Strata server to manage all your tools.
```bash Stdio Mode (Default) theme={null}
strata
```
```bash HTTP/SSE Mode theme={null}
strata run --port 8080
```
Use the Strata tool to add your AI client.
```bash Claude Code theme={null}
strata tool add claude
```
```bash Cursor theme={null}
strata tool add cursor
```
```bash VSCode theme={null}
strata tool add vscode
```
If you're interested in 1:1 mapping between API and tool using our MCP Server Instance, [check here](/legacy/instance).
## Next steps
Integrate Klavis MCP Servers with leading AI platforms
Explore available MCP servers
Progressive tool discovery across apps
REST endpoints and schemas
## Prerequisites
Before we begin, you'll need:
## Prerequisites
Before we begin, you'll need:
## Prerequisites
Before we begin, you'll need [OpenAI API key](https://platform.openai.com/api-keys) and [Klavis API key](https://www.klavis.ai/home/api-keys).
## OAuth Flow (w/ white-label)
```mermaid theme={null}
sequenceDiagram
actor EndUser
participant ClientApp as Your App
participant KlavisAI as Klavis AI
participant ThirdPartyIdP as Third-party App
%% --- OAuth Flow Initiation ---
EndUser->>ClientApp: 1. Initiates action in Your App
## How MCP Works
MCP follows a simple **client-server architecture**:
* **MCP Client**: The AI assistant or application (like Claude Desktop, Cursor, or your custom AI agent)
* **MCP Server**: A specialized backend that exposes tools to interact with external systems
* **Tools**: Individual functions that the AI can call to perform specific actions
```mermaid theme={null}
graph LR
A[AI Agent] -->|Request| B[MCP Client]
B -->|Tool Call| C[MCP Server]
C -->|API Call| D[External Service]
D -->|Response| C
C -->|Result| B
B -->|Context| A
```
## Key Benefits
# What is Strata?
**Strata** is one MCP server that guides AI agents use tools reliably at any complexity, instead of overwhelming them with everything at once, it was designed by thinking human interacting with tools, solving the three major problems that plague AI agents today:
* **Tool Overload**: Too many tools cause LLM choice paralysis
* **Context Overload**: Long tool lists blow up token counts and costs
* **Coverage Gap**: Most servers are stuck at 40\~50 tools, limiting what you can build
You can use Strata via our [website](https://www.klavis.ai/home/mcp-servers), [API](https://www.klavis.ai/docs/api-reference/strata/create), or even [open source](https://github.com/Klavis-AI/klavis) on your own data!
## Video Tutorial
Watch this video tutorial for a complete understanding of how Strata works:
## Text Tutorial
## Overview
Klavis Guardrails is a comprehensive security layer designed to protect MCP (Model Context Protocol) integrations from emerging threats. It operates as an intelligent proxy between MCP clients and servers, providing real-time threat detection and policy enforcement.
## The Security Challenge
MCP's architecture amplifies security risks by exposing tools, resources, and prompts directly to AI agents. Recent vulnerabilities demonstrate critical flaws:
* **Prompt Injection via Tool Descriptions**: Malicious instructions embedded in MCP tool metadata
* **Cross-Repository Information Leakage**: Agents coerced into accessing private repositories
* **Command Injection and RCE**: Basic security flaws allowing arbitrary code execution
* **Credential Theft**: MCP servers storing OAuth tokens become high-value targets
## Security Architecture
Klavis Guardrails operates as a security proxy that intercepts, analyzes, and enforces policies on all MCP communication in real-time with four key protection mechanisms:
**Tool Poisoning Detection**: Monitors MCP tool metadata using behavioral analysis to identify when tools deviate from declared functionality.
**Prompt Injection Prevention**: Uses advanced NLP to analyze prompts for malicious instructions, detecting sophisticated attacks before they reach the model.
**Privilege Escalation Monitoring**: Enforces granular access controls ensuring MCP servers operate under least privilege principles.
**Command Injection Mitigation**: Performs deep inspection of tool invocations with strict allowlists and input sanitization.
## Get Started
**Ready to secure your MCP infrastructure?** Join our beta by [scheduling a 15-minute call](https://cal.com/zihao-lin-u35ykt/15min) with us, or reach out directly at [security@klavis.ai](mailto:security@klavis.ai).
# Installation
Source: https://www.klavis.ai/docs/installation
Install Klavis SDK or use REST API directly
## SDK Installation
## Step 2: Register an Integration
1. Enter **"Name"**
2. Add redirect URLs: `https://api.klavis.ai/oauth/airtable/callback`
3. Click **"Register Integration"**
Here is an example of Klavis AI OAuth app configuration:
Once registered, Airtable will generate your Client ID and Client Secret. Youāll need these for connecting Klavis AI.
## Step 3: Request Scopes
2. Enter Required Info, Then click **"Save Changes"**
## Step 2: Create a New App
1. Once logged in, go to your settings -> **Apps**, and click **"Build new apps"**
2. Click **"Create new app"** under **"My apps"** section
3. Fill in the app details:
* **App name**: Your application name (e.g., your brand name)
* **Which best describes what your app will do?**: (Choose your preference)
* **Asana API Terms**: Agree to the terms and conditions
## Step 3: Configure OAuth Settings
1. After creating the app, you'll see:
* **Client ID**: Copy this value
* **Client Secret**: Copy this value (keep it secure!)
2. **Redirect URIs**: Add your callback URL:
* `https://api.klavis.ai/oauth/asana/callback`
## Step 4: Request Scopes
## Step 2: Create a New App
1. Once logged in, go to **"Accounts"** -> **"My Apps"**
2. Click **"Create a new app"**
3. Choose **"Web App"** as the integration type
4. Fill in the app details:
* **Name of app**: Your application name (e.g., your brand name)
* **Kind of app**: Web/Native (depending on your need)
* **Environment Type**: Sandbox/Production (**Production** recommended)
* **Redirect URIs**: Add your callback URL:
* `https://api.klavis.ai/oauth/calendly/callback`
**With password configured (showing MFA option):**
## Step 1: Create Canva Developer Account & Integration
1. Visit [https://developer.canva.com/](https://developer.canva.com/) and sign in with your Canva credentials
2. Navigate to **"Your integrations"** page
3. Click **"Create an integration"** and fill out the form:
* **Integration type**: Choose between "Public" (available to all users after review) or "Private" (team only)
* **Integration name**: Choose a descriptive name
* Accept Canva's Developer Terms
## Step 2: Configure Integration Settings
1. Under **"Configuration"** ā **"Configure your integration"**, set the following:
* **Integration name**: Add your application name
* **Client ID**: Make note of this value for later use
* **Generate secret**: Click to generate and securely save your Client Secret
## Step 3: Set Required Scopes
## Step 4: Configure Authentication & Redirect URLs
1. Under **"Authentication"** ā **"Add Authentication"**, add redirect URL:
* `https://api.klavis.ai/oauth/canva/callback`
## Step 5: Submit for Review (Public Integrations Only)
## Step 6: Integration Review Status
Once submitted, your integration will show "In Review" status. You'll receive email notifications about the review progress, and you will be asked to complete a questionnaire in the Jira ticket from the email.
## Step 2: Create a New App
1. Once logged in, go to **"Applications"** in your developer dashboard
2. Click **"New Application"** to create a new app
3. Click on the **"App"** that you just created
4. Go to **"General Information"** section
5. Fill in the app details:
* **App name**: Your application name (e.g., your brand name)
* **App description**: Your application description
* **"App Icon"**: Upload 100x100px PNG (recommended)
* **"Tags"**: Add tags that describe your application
* **Privacy policy URL**: Your privacy policy URL
* **Terms of service URL**: Your terms of service URL
## Step 3: Build A Bot
1. Go to **"Bot"** section.
2. Get **Discord Token**:
* Click on **Reset Token** button under **TOKEN** tab
* Enter your **Discord Password** and press **Submit**
* New **Token** has been generated
* **Copy** this token (keep it secure!)
3. Set **Bot Permissions**:
* Choose **Administrator** under **General Permissions** (recommended)
2. Generate URL:
* Integration Type: **Guild Install** (recommended)
* Copy **Generated URL** and paste in browser to complete authentication
## Step 2: Configure OAuth Settings
1. After creating the app, you'll be redirected to the app settings page
2. In **"OAuth 2"** section, add redirect URLs:
* `https://api.klavis.ai/oauth/dropbox/callback`
3. Note your **App key** and **App secret**
## Step 3: Set Required Permissions
2. Click **"Submit"** to save your permission settings
## Step 2: Create a New App
1. Once logged in, go to your developer dashboard -> **"My Apps"**
2. Click **"Create a new app"**
3. Fill in the app details:
* **App name**: Your application name (e.g., your brand name)
* **Website**: Your company website
* **App logo**: Upload 100x100px PNG (recommended)
## Step 3: Get Your Credentials
2. Click **New Project**.
3. Enter the project details and click **Create**.
4. Select your newly created project.
5. Go to **APIs & Services**.
6. Click **Enable APIs and Services**.
7. Search for and select **Gmail API**.
8. Click **Enable**.
9. Go back to **APIs & Services** and select **OAuth consent screen**.
10. Enter the required information and save.
11. Go to **Credentials** in APIs & Services and click **Create Credentials**.
12. Select **OAuth Client ID**.
13. Choose **Web Application** and enter the required details.
14. Add redirect URLs:
`https://api.klavis.ai/oauth/gmail/`
Then click **Create**.
15. Your **Client ID** and **Client Secret** will be displayed.
## Step 2: Request Scopes
2. Click **Data Access**.
3. Click **Add or Remove Scopes**.
4. Enter the needed scopes and click **Update**.
2. Click **New Project**.
3. Enter the project details and click **Create**.
4. Select your newly created project.
5. Go to **APIs & Services**.
6. Click **Enable APIs and Services**.
7. Search for and select **Google Calendar API**.
8. Click **Enable**.
9. Go back to **APIs & Services** and select **OAuth consent screen**.
10. Enter the required information and save.
11. Go to **Credentials** in APIs & Services and click **Create Credentials**.
12. Select **OAuth Client ID**.
13. Choose **Web Application** and enter the required details.
14. Add redirect URLs:
`https://api.klavis.ai/oauth/gcalendar/callback`
Then click **Create**.
15. Your **Client ID** and **Client Secret** will be displayed.
## Step 2: Request Scopes
2. Click **Data Access**.
3. Click **Add or Remove Scopes**.
4. Enter the needed scopes and click **Update**.
2. Click **New Project**.
3. Enter the project details and click **Create**.
4. Select your newly created project.
5. Go to **APIs & Services**.
6. Click **Enable APIs and Services**.
7. Search for and select **Google Docs API**.
8. Click **Enable**.
9. Go back to **APIs & Services** and select **OAuth consent screen**.
10. Enter the required information and save.
11. Go to **Credentials** in APIs & Services and click **Create Credentials**.
12. Select **OAuth Client ID**.
13. Choose **Web Application** and enter the required details.
14. Add redirect URLs:
`https://api.klavis.ai/oauth/gdocs/callback`
Then click **Create**.
15. Your **Client ID** and **Client Secret** will be displayed.
## Step 2: Request Scopes
2. Click **Data Access**.
3. Click **Add or Remove Scopes**.
4. Enter the needed scopes and click **Update**.
2. Click **New Project**.
3. Enter the project details and click **Create**.
4. Select your newly created project.
5. Go to **APIs & Services**.
6. Click **Enable APIs and Services**.
7. Search for and select **Google Drive API**.
8. Click **Enable**.
9. Go back to **APIs & Services** and select **OAuth consent screen**.
10. Enter the required information and save.
11. Go to **Credentials** in APIs & Services and click **Create Credentials**.
12. Select **OAuth Client ID**.
13. Choose **Web Application** and enter the required details.
14. Add redirect URLs:
`https://api.klavis.ai/oauth/gdrive/callback`
Then click **Create**.
15. Your **Client ID** and **Client Secret** will be displayed.
## Step 2: Request Scopes
2. Click **Data Access**.
3. Click **Add or Remove Scopes**.
4. Enter the needed scopes and click **Update**.
2. Click **New Project**.
3. Enter the project details and click **Create**.
4. Select your newly created project.
5. Go to **APIs & Services**.
6. Click **Enable APIs and Services**.
7. Search for and select **Google Sheets API**.
8. Click **Enable**.
9. Go back to **APIs & Services** and select **OAuth consent screen**.
10. Enter the required information and save.
11. Go to **Credentials** in APIs & Services and click **Create Credentials**.
12. Select **OAuth Client ID**.
13. Choose **Web Application** and enter the required details.
14. Add redirect URLs:
`https://api.klavis.ai/oauth/gsheets/callback`
Then click **Create**.
15. Your **Client ID** and **Client Secret** will be displayed.
## Step 2: Request Scopes
2. Click **Data Access**.
3. Click **Add or Remove Scopes**.
4. Enter the needed scopes and click **Update**.
## Step 2: Configure OAuth Settings
1. Go to the **"Auth"** tab in your application dashboard
2. Add redirect URLs: `https://api.klavis.ai/oauth/hubspot/callback`
Here is an example of Klavis AI OAuth app configuration:
## Step 3: Request Scopes
## Step 4: Create App
1. Now Click the **"Create App"** Button
## Step 2: Configure OAuth Settings
1. Go to the **"Auth"** tab in your application dashboard
2. Add redirect URLs: `https://api.klavis.ai/oauth/linkedin/callback`
Here is an example of Klavis AI OAuth app configuration:
## Step 3: Request Scopes
3. Under **Redirect URLs**, add:
```
https://api.klavis.ai/oauth/monday/callback
```
## Step 3: Promote to Live
1. Once everything is set up, click **Promote to Live**.
Your app will now have permanent credentials and can be used in production
From This, You will Get Your Client ID and Client secret.
## Step 2: Request Scopes
## Step 2: Configure API Permissions
## Step 3: Collect Client ID & Secret
1. Go to **Certificates & Secrets** tab
2. Click **New client secret** ā set description + expiry ā **Add**
3. Copy the **Client Secret Value** (shown only once)
4. From **Overview** tab, copy **Application (client) ID**
2. Click **"Create a workspace"** to set up your development environment
3. Fill out the workspace creation form with three steps:
* **Step 1 - Basic Information**: Enter workspace name and description
* **Step 2 - Company Information**: Provide your company details
* **Step 3 - Contact Information**: Add your contact information
4. Click **"Create workspace"** to complete the setup
## Step 2: Create QuickBooks OAuth Application
1. After workspace creation, click **"Create an app"** to start building your QuickBooks integration
2. In the app creation dialog, select app type and configure basic information:
* **Choose "QuickBooks Online"** as your app type
* **Enter your app name** (avoid using "Intuit" or "QuickBooks" in the name)
* **Provide app description**
## Step 3: Configure OAuth Permissions
2. Review and confirm the permissions by clicking **"Confirm"**
## Step 4: Access Your OAuth Credentials
1. Once your app is created, you'll see the success page with your development credentials
2. Navigate to **"Keys and credentials"** in the left sidebar to view your OAuth credentials:
* **Client ID**: Your OAuth application identifier
* **Client Secret**: Your OAuth application secret (keep this secure)
3. Configure your redirect URIs:
* For Klavis integration: `https://api.klavis.ai/oauth/quickbooks/callback`
* For local development: `http://localhost:3000/oauth/quickbooks/callback`
## Step 2: Enable Connected Apps
1. Once logged in, go to **"Setup Menu"** (Gear Icon) and click **"Setup"**
2. Search **"External Client Apps"** in the **"Quick Find"** search box
3. In **"External Client App Settings"**, enable **"Allow creation of connected apps"**
4. Click **"New Connected App"**
## Step 3: Fill Basic App Information
1. Fill the necessary app details:
* **Connected App Name**: Your application name (e.g., your brand name)
* **API Name**: Auto-generated from app name (only letters, numbers, and underscores allowed)
* **Contact Email**: Your contact email for Salesforce support
* **Contact Phone**: Your contact phone for Salesforce support
* **Logo Image URL**: (Optional) HTTPS URL for your app logo (max 100 KB, preferably under 20 KB)
* **Info URL**: (Optional) Web page with more information about your app
* **Description**: (Optional) Up to 256 characters describing your app
4. In the **API (Enable OAuth Settings)** section, click **"Manage Consumer Details"**
5. Verify your identity using the **verification code** sent to your email
6. Copy the **Consumer Key** and **Consumer Secret** (keep them secure!)
## (Optional) Step 5: White Labeling
## Step 2: Configure OAuth Settings
1. Go to the **"OAuth & Permissions"** tab in your application dashboard
2. Add redirect URLs: `https://api.klavis.ai/oauth/slack/callback`
3. Click **"Save URLs"**
Here is an example of Klavis AI OAuth app configuration:
## Step 3: Request Scopes
## (Optional) Step 5: White Labeling
## Step 2: Create a New App
1. Once logged in, go to your developer dashboard
2. Click **"New app"** or **"Create an app"**
3. Choose **"Web App"** as the integration type
4. Fill in the app details:
* **App name**: Your application name (e.g., your brand name)
* **Company or application URL**: Your company website
* **Privacy policy URL**: Your privacy policy URL
* **Terms of service URL**: Your terms of service URL
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
**Copy** the strata URL to clipboard - you'll need this in the next step.
**NOTE**: Developer Mode is required to add custom MCP servers in ChatGPT Connectors. See below screenshot for comparison:
To verify server tools:
* Go to **Setting** > **Apps & Connectors**
* Select your MCP > Scroll to **Actions** tab
Open ChatGPT Chat and start using natural language:
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
**Copy** the strata URL to clipboard - you'll need this in the next step.
To view available tools in the MCP server, navigate to Strata server and click `View Tools`.
Open Claude Code Chat and start using natural language:
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
**Copy** the strata URL to clipboard - you'll need this in the next step.
Select **"Add Custom Connector"**:
* **Name**: `strata`
* **Remote MCP Server URL**: Paste your Strata Server URL that you copied earlier
Click **Add** to save the configuration. You can see strata added to the list.
Open **strata** to see the list of tools available from your Strata MCP server.
Open Claude Web/Desktop Chat (`Cmd/Ctrl + L`) and start using natural language:
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
**Copy** the strata URL to clipboard - you'll need this in the next step.
Tap on **"Configure MCP Servers"** to open the configuration file.
Paste Your Server URL to **`cline_mcp_settings.json`** file like the screenshot below
Open Cline Chat and start using natural language:
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
**Copy** the strata URL to clipboard - you'll need this in the next step.
Click on "**+**" (plus icon) to create a new MCP server configuration for Strata
Paste Your Strata Server URL to **"new-mcp-server.yaml"** file like the screenshot below
Open Continue Chat (`Cmd/Ctrl + L`) and start using natural language:
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
Cursor will automatically open the **MCP** dialog with Strata Server URL pre-filled. Click **Install** to save the configuration.
3. Paste the below code in **mcp.json** file (See Screenshot below)
Tap on **klavis-strata** to view the list of tools loaded from Strata server.
Open Cursor Chat (`Cmd/Ctrl + L`) and start using natural language:
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
**Copy** the strata URL to clipboard - you'll need this in the next step.
Open Gemini CLI Chat and start using natural language:
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
**Copy** the strata URL to clipboard - you'll need this in the next step.
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
From Klavis Dashboard, click **"Add to Other Clients"** button to get your Strata Server URL.
1. Navigate to **n8n**
2. MCP URL with custom auth headers enabled: `https://strata.klavis.ai/mcp/` (Copy it)
3. Click on **"Generate Token"** to get **Bearer Token** (Copy token & keep it secret!)
Click the **Add First Step ('+' icon)** and select **Trigger Manually** to kickstart your workflow and you should see your first node being created.
1. Click **"+ (What happens next?)"**
2. Navigate to **AI** ā **AI Agents** from the menu
3. Configure Your AI Agent:
* **Source for Prompt**: choose "Connected Chat Trigger Node"
* **Prompt**: `{{ $json.chatInput }}` (default setting)
4. Click **Back to Canvas** to save the agent
You should see **"When Chat Message Received"** and **"AI Agent"** nodes appear on the workflow diagram.
1. Click **"+ (Chat Model)"** -> **Anthropic Chat Model** (or your preferred model)
2. Connect Chat Model to **n8n** using API Key
3. Select **Model**: Claude Sonnet 4.5 (for example)
4. Click **Back to Canvas** to lock in your chat model configuration
Your **Chat Model** node now elegantly connects to your **AI Agent** node.
1. Click **"+ (Tool)"** -> **"MCP Client Tool"**
2. Configure Your MCP Client:
* Endpoint: Paste `https://strata.klavis.ai/mcp/`
* Server Transport: **HTTP Streamable**
* Authentication: **Bearer Auth**
* Credentials for Bearer Auth: Paste **Bearer Token** that you copied earlier
* Tools to Include: **All** (highly recommended for maximum capabilities)
3. Click **Back to Canvas** to save your MCP Client
To connect your bearer account to n8n, simply paste **"Bearer Token"** that you copied from Klavis Dashboard.
1. Navigate to **Connection** menu
2. Bearer Token: Paste your **"Bearer Auth Token"**
3. Allowed HTTP Request Domains: **All** (default settings)
Now, AI workflow diagram has been completed and should look similar to screenshot below.
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
VS Code will automatically open the **MCP** dialog with Strata Server URL pre-filled. Click **Install** to save the configuration.
Paste Your Server URL to **settings.json** file like the screenshot below
Open Chat (`Cmd/Ctrl + I`) and start using natural language:
Click the **"Authorize"** button next to your chosen server. Once server is authorized, you will see **Green Checkmark** status.
**Copy** the strata URL to clipboard - you'll need this in the next step.
Navigate to **Cascade** and click **Manage MCPs** > **View raw config**.
Paste Your Server URL to **mcp\_config.json** file like the screenshot below.
Open Windsurf Chat (`Cmd/Ctrl + Shift + L`) and start using natural language:
