> ## Documentation Index
> Fetch the complete documentation index at: https://www.klavis.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# 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.

![CrewAI and Klavis Integration - Automate your next sales follow-up](https://mintcdn.com/klavisai/ojd5sBgaQMqaHcSS/images/ai-platform/crewai-klavis.png?fit=max\&auto=format\&n=ojd5sBgaQMqaHcSS\&q=85\&s=159d7d5a518785312f938360a081afa0)

## Prerequisites

Before we begin, you'll need:

> [card] [OpenAI API Key](https://platform.openai.com/api-keys)
>
> Get your API key from OpenAI Platform (CrewAI uses OpenAI as the default model)

> [card] [Klavis AI API Key](https://klavis.ai/)
>
> 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);
        });
    }
}

```

> [!NOTE]
>
> **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}`);
```

> [!TIP]
>
> 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:

> [card] Communication
>
> Gmail, Slack, Discord, Outlook

> [card] Content & Media
>
> YouTube, Notion, Google Docs, WordPress

> [card] Development
>
> GitHub, Jira, Linear, Confluence

> [card] Data & Analytics
>
> Google Sheets, Supabase, PostgreSQL

> [card] Business Tools
>
> Salesforce, HubSpot, Asana, ClickUp

> [card] Cloud Storage
>
> 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! 🚀👥


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.