How do I use multiple MCP servers (Firecrawl Deep Research, Firecrawl Web Search, Plai) with CrewAI?

CrewAI excels at connecting to multiple MCP servers simultaneously, enabling sophisticated multi-agent collaborations. You can configure each Firecrawl Deep Research, Firecrawl Web Search, Plai server independently and distribute their tools across different agents in your crew. This creates specialized agents that work together, each leveraging specific Firecrawl Deep Research, Firecrawl Web Search, Plai capabilities to accomplish complex tasks through coordinated teamwork. Klavis AI simplifies multi-server management with centralized configuration and unified agent orchestration for CrewAI applications.

What are the benefits of using Firecrawl Deep Research and Firecrawl Web Search and Plai together in CrewAI crews?

Combining Firecrawl Deep Research and Firecrawl Web Search and Plai in your CrewAI crews creates powerful collaborative AI systems. Different agents can specialize in different services, enabling sophisticated task distribution where one agent might gather data from one service while another processes it through another, all coordinated through CrewAI's intelligent workflow management and inter-agent communication.

Do I need special CrewAI packages for MCP server integration?

Yes, you'll need the CrewAI tools package and the CrewAI MCP adapter (crewai-tools) for MCP server integration. Klavis AI provides detailed package requirements and automated installation scripts for each supported MCP server, along with CrewAI-specific configuration examples, agent setup guides, and crew orchestration patterns to ensure smooth multi-agent system deployment.

Can I assign different MCP servers to different CrewAI agents?

Absolutely! This is one of CrewAI's strongest features when working with MCP servers. You can create specialized agents by assigning specific MCP server tools to each agent based on their role and expertise. For example, one agent might handle data retrieval while another focuses on analysis, each using tools from different MCP servers that match their specialized functions.

How do I handle authentication for MCP servers in CrewAI crews?

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

How do CrewAI agents collaborate when using these MCP servers?

CrewAI agents collaborate through sophisticated task delegation and result sharing. When using these MCP servers, agents can pass data between each other, coordinate complex workflows, and make collective decisions based on information gathered from external services. CrewAI's Process.Sequential and hierarchical agent structures ensure efficient collaboration and optimal task execution order.

What types of CrewAI crews benefit most from MCP server integration?

CrewAI crews that benefit most include: research and analysis teams that need to gather data from multiple sources, customer service crews requiring integration with various platforms, content creation teams that need access to different tools and APIs, and complex workflow automation crews that perform multi-step processes across different services. MCP servers enable CrewAI crews to extend beyond AI reasoning to real-world action and data access.

How does MCP server integration affect CrewAI crew performance?

MCP server integration adds network latency for external API calls, but CrewAI's asynchronous agent execution helps manage multiple MCP server calls efficiently across the crew. Best practices include assigning appropriate tools to specialized agents, implementing proper error handling and fallback strategies, and using CrewAI's built-in retry mechanisms. Klavis AI provides performance monitoring tools and crew optimization recommendations to ensure your multi-agent systems run at peak efficiency.

Can CrewAI agents share MCP server data with each other?

Yes, CrewAI agents can share data obtained from MCP servers through the framework's built-in inter-agent communication system. Agents can pass results from MCP server tools to other agents in the crew, enabling sophisticated collaborative workflows where one agent's MCP server interaction becomes input for another agent's tasks. This creates powerful data processing pipelines across your entire crew.

Why choose Klavis AI for CrewAI MCP server connections?

Klavis AI provides the most comprehensive platform for CrewAI MCP server integration with features like pre-built CrewAI connectors, automated crew setup scripts, detailed documentation with multi-agent examples, secure credential management, and crew performance optimization guides. Our platform is specifically designed to make CrewAI + MCP server integration as seamless as possible for developers building collaborative AI systems. With Klavis AI's centralized management dashboard, you can monitor all your crew activities, track agent performance across MCP server interactions, and troubleshoot multi-agent workflows from a single interface.

Connectto Firecrawl Deep Research, Firecrawl Web Search, Plai MCP Servers

Create powerful AI workflows by connecting multiple MCP servers including Firecrawl Deep Research, Firecrawl Web Search, Plai for enhanced automation capabilities in Klavis AI.

Get Started Free View All MCP Servers

Firecrawl Deep Research

featured

A personal research assistant that analyze sources across the web, based on Firecrawl

Available Tools:

firecrawl_deep_research

Firecrawl Web Search

featured

Advanced web crawling, scraping, and search capabilities powered by Firecrawl

Available Tools:

firecrawl_scrape
firecrawl_map
firecrawl_crawl
+6 more tools

Plai

featured

Plai is an AI-powered advertising platform that simplifies creating, managing, and optimizing Facebook, Instagram, and LinkedIn ad campaigns. It provides tools for lead generation, campaign insights, and automated ad management to help businesses scale their digital marketing efforts effectively.

Available Tools:

plai_create_user_profile
plai_get_user_profile
plai_create_link
+7 more tools

Connect Using Klavis UI

The easiest way to connect these MCP servers to your AI clients

View Step by Step Guide

Navigate to Klavis Home

Visit the Klavis home page and you will see a list of MCP servers available in Klavis.

Authorize Your Servers

Click the "Authorize" button next to your chosen servers. Once servers are authorized, you will see a Green Checkmark status.

Add to Your AI Client

Click "Add to Cursor", "Add to VS Code", "Add to Claude" or "Add to Other Clients" button to connect the MCP server to your preferred AI client.

Connect Using API

Programmatically connect your AI agents to these MCP servers

Get Your API Key

Configure Connections

Use the code examples below to add your desired MCP servers to your AI client and configure authentication settings.

Test & Deploy

Verify your connections work correctly and start using your enhanced AI capabilities.

Integrate in minutes, Scale to millions

View Documentation

import os
from crewai import Agent, Task, Crew, Process
from crewai_tools import MCPServerAdapter
from klavis import Klavis
from klavis.types import McpServerName

# Initialize clients
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))

# Create strata server with all MCP servers
response = klavis_client.mcp_server.create_strata_server(
    servers=[McpServerName.FIRECRAWL_DEEP_RESEARCH, McpServerName.FIRECRAWL_WEB_SEARCH, McpServerName.PLAI],
    user_id="1234"
)

mcp_server_url = response.strata_server_url

# Initialize MCP tools from strata server
with MCPServerAdapter(mcp_server_url) as mcp_tools:
    # Create agent with access to all MCP server tools
    strata_agent = Agent(
        role="Multi-Service Specialist",
        goal="Handle tasks across multiple services and data sources",
        backstory="You are an expert at coordinating and analyzing data from multiple services",
        tools=mcp_tools,
        reasoning=True,
        verbose=False
    )
    
    # Define Task
    research_task = Task(
        description="Gather and analyze comprehensive data from all available sources",
        expected_output="Complete analysis with structured summary and key insights",
        agent=strata_agent,
        markdown=True
    )
    
    # Create and execute the crew
    crew = Crew(
        agents=[strata_agent],
        tasks=[research_task],
        verbose=False,
        process=Process.sequential
    )
    
    result = crew.kickoff()

Code Examples for claude

import os
from anthropic import Anthropic
from klavis import Klavis
from klavis.types import McpServerName, ToolFormat

# Initialize clients
anthropic_client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))

# Constants
CLAUDE_MODEL = "claude-3-5-sonnet-20241022"
user_message = "Your message here"

# Create strata server with all MCP servers
response = klavis_client.mcp_server.create_strata_server(
    servers=[McpServerName.FIRECRAWL_DEEP_RESEARCH, McpServerName.FIRECRAWL_WEB_SEARCH, McpServerName.PLAI],
    user_id="1234"
)

mcp_server_url = response.strata_server_url

# Get tools from the strata server
mcp_tools = klavis_client.mcp_server.list_tools(
    server_url=mcp_server_url,
    format=ToolFormat.ANTHROPIC,
)

messages = [
    {"role": "user", "content": user_message}
]

response = anthropic_client.messages.create(
    model=CLAUDE_MODEL,
    max_tokens=4000,
    messages=messages,
    tools=mcp_tools.tools
)

import Anthropic from '@anthropic-ai/sdk';
import { KlavisClient, Klavis } from 'klavis';

// Initialize clients
const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });

const CLAUDE_MODEL = "claude-3-5-sonnet-20241022";
const userMessage = "Your message here";

// Create strata server with all MCP servers
const strataResponse = await klavisClient.mcpServer.createStrataServer({
    servers: [Klavis.McpServerName.FirecrawlDeepResearch, Klavis.McpServerName.FirecrawlWebSearch, Klavis.McpServerName.Plai],
    userId: "1234"
});

const mcpServerUrl = strataResponse.strataServerUrl;

// Get tools from the strata server
const mcpTools = await klavisClient.mcpServer.listTools({
    serverUrl: mcpServerUrl,
    format: Klavis.ToolFormat.Anthropic,
});

const response = await anthropic.messages.create({
    model: CLAUDE_MODEL,
    max_tokens: 4000,
    messages: [{ role: 'user', content: userMessage }],
    tools: mcpTools.tools,
});

Code Examples for openai

import os
from openai import OpenAI
from klavis import Klavis
from klavis.types import McpServerName, ToolFormat

# Initialize clients
openai_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))

# Constants
OPENAI_MODEL = "gpt-4o-mini"
user_message = "Your query here"

# Create strata server with all MCP servers
response = klavis_client.mcp_server.create_strata_server(
    servers=[McpServerName.FIRECRAWL_DEEP_RESEARCH, McpServerName.FIRECRAWL_WEB_SEARCH, McpServerName.PLAI],
    user_id="1234"
)

mcp_server_url = response.strata_server_url

# Get tools from the strata server
mcp_tools = klavis_client.mcp_server.list_tools(
    server_url=mcp_server_url,
    format=ToolFormat.OPENAI,
)

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": user_message}
]

response = openai_client.chat.completions.create(
    model=OPENAI_MODEL,
    messages=messages,
    tools=mcp_tools
)

import OpenAI from 'openai';
import { KlavisClient, Klavis } from 'klavis';

// Initialize clients
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });

const OPENAI_MODEL = "gpt-4o-mini";
const userMessage = "Your query here";

// Create strata server with all MCP servers
const strataResponse = await klavisClient.mcpServer.createStrataServer({
    servers: [Klavis.McpServerName.FirecrawlDeepResearch, Klavis.McpServerName.FirecrawlWebSearch, Klavis.McpServerName.Plai],
    userId: "1234"
});

const mcpServerUrl = strataResponse.strataServerUrl;

// Get tools from the strata server
const mcpTools = await klavisClient.mcpServer.listTools({
    serverUrl: mcpServerUrl,
    format: Klavis.ToolFormat.Openai,
});

const response = await openai.chat.completions.create({
    model: OPENAI_MODEL,
    messages: [
        { role: 'system', content: 'You are a helpful assistant.' },
        { role: 'user', content: userMessage }
    ],
    tools: mcpTools,
});

Code Examples for gemini

import os
from google import genai
from klavis import Klavis
from klavis.types import McpServerName, ToolFormat

# Initialize clients
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
client = genai.Client(api_key=os.getenv("GOOGLE_API_KEY"))

user_message = "Your query here"

# Create strata server with all MCP servers
response = klavis_client.mcp_server.create_strata_server(
    servers=[McpServerName.FIRECRAWL_DEEP_RESEARCH, McpServerName.FIRECRAWL_WEB_SEARCH, McpServerName.PLAI],
    user_id="1234"
)

mcp_server_url = response.strata_server_url

# Get tools from the strata server
mcp_tools = klavis_client.mcp_server.list_tools(
    server_url=mcp_server_url,
    format=ToolFormat.GEMINI,
)

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=user_message,
    config=genai.types.GenerateContentConfig(
        tools=mcp_tools.tools,
    ),
)

import { GoogleGenAI } from '@google/genai';
import { KlavisClient, Klavis } from 'klavis';

// Initialize clients
const ai = new GoogleGenAI({ apiKey: process.env.GOOGLE_API_KEY });
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });

const userMessage = "Your query here";

// Create strata server with all MCP servers
const strataResponse = await klavisClient.mcpServer.createStrataServer({
    servers: [Klavis.McpServerName.FirecrawlDeepResearch, Klavis.McpServerName.FirecrawlWebSearch, Klavis.McpServerName.Plai],
    userId: "1234"
});

const mcpServerUrl = strataResponse.strataServerUrl;

// Get tools from the strata server
const mcpTools = await klavisClient.mcpServer.listTools({
    serverUrl: mcpServerUrl,
    format: Klavis.ToolFormat.Gemini,
});

const response = await ai.models.generateContent({
    model: "gemini-2.5-flash",
    contents: userMessage,
    tools: mcpTools.tools,
});

Code Examples for langchain

import os
import asyncio
from klavis import Klavis
from klavis.types import McpServerName
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

# Initialize clients
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))
llm = ChatOpenAI(model="gpt-4o-mini", api_key=os.getenv("OPENAI_API_KEY"))

# Create strata server with all MCP servers
response = klavis_client.mcp_server.create_strata_server(
    servers=[McpServerName.FIRECRAWL_DEEP_RESEARCH, McpServerName.FIRECRAWL_WEB_SEARCH, McpServerName.PLAI],
    user_id="1234"
)

mcp_server_url = response.strata_server_url

mcp_client = MultiServerMCPClient({
    "strata": {
        "transport": "streamable_http",
        "url": mcp_server_url
    }
})

tools = asyncio.run(mcp_client.get_tools())

agent = create_react_agent(
    model=llm,
    tools=tools,
)

response = asyncio.run(agent.ainvoke({
    "messages": [{"role": "user", "content": "Your query here"}]
}))

import { KlavisClient, Klavis } from 'klavis';
import { MultiServerMCPClient } from "@langchain/mcp-adapters";
import { ChatOpenAI } from "@langchain/openai";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

// Initialize clients
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });
const llm = new ChatOpenAI({ model: "gpt-4o-mini", apiKey: process.env.OPENAI_API_KEY });

// Create strata server with all MCP servers
const strataResponse = await klavisClient.mcpServer.createStrataServer({
    servers: [Klavis.McpServerName.FirecrawlDeepResearch, Klavis.McpServerName.FirecrawlWebSearch, Klavis.McpServerName.Plai],
    userId: "1234"
});

const mcpServerUrl = strataResponse.strataServerUrl;

const mcpClient = new MultiServerMCPClient({
    "strata": {
        transport: "streamable_http",
        url: mcpServerUrl
    }
});

const tools = await mcpClient.getTools();

const agent = createReactAgent({
    llm: llm,
    tools: tools,
});

const response = await agent.invoke({
    messages: [{ role: "user", content: "Your query here" }]
});

Code Examples for llamaindex

import os
from klavis import Klavis
from klavis.types import McpServerName
from llama_index.tools.mcp import (
    BasicMCPClient,
    aget_tools_from_mcp_url,
)
from llama_index.core.agent.workflow import FunctionAgent

# Initialize clients
klavis_client = Klavis(api_key=os.getenv("KLAVIS_API_KEY"))

# Create strata server with all MCP servers
response = klavis_client.mcp_server.create_strata_server(
    servers=[McpServerName.FIRECRAWL_DEEP_RESEARCH, McpServerName.FIRECRAWL_WEB_SEARCH, McpServerName.PLAI],
    user_id="1234"
)

mcp_server_url = response.strata_server_url

# Get tools from the strata server
strata_tools = await aget_tools_from_mcp_url(
    mcp_server_url, 
    client=BasicMCPClient(mcp_server_url)
)

# Create agent with all tools
agent = FunctionAgent(
    name="strata_agent",
    tools=strata_tools,
    llm=llm,
)

import { KlavisClient, Klavis } from 'klavis';
import { mcp } from "@llamaindex/tools";
import { agent } from "@llamaindex/workflow";
import { openai } from "@llamaindex/llm";

// Initialize clients
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });

// Create strata server with all MCP servers
const strataResponse = await klavisClient.mcpServer.createStrataServer({
    servers: [Klavis.McpServerName.FirecrawlDeepResearch, Klavis.McpServerName.FirecrawlWebSearch, Klavis.McpServerName.Plai],
    userId: "1234"
});

const mcpServerUrl = strataResponse.strataServerUrl;

// Create MCP server connection
const strataServer = mcp({
    url: mcpServerUrl,
    verbose: true,
});

// Get tools from strata server
const strataTools = await strataServer.tools();

// Create agent with all tools
const strataAgent = agent({
    name: "strata_agent",
    llm: openai({ model: "gpt-4o" }),
    tools: strataTools,
});

Code Examples for fireworks-ai

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

user_message = "Your query here"

# Create strata server with all MCP servers
response = klavis_client.mcp_server.create_strata_server(
    servers=[McpServerName.FIRECRAWL_DEEP_RESEARCH, McpServerName.FIRECRAWL_WEB_SEARCH, McpServerName.PLAI],
    user_id="1234"
)

mcp_server_url = response.strata_server_url

# Get tools from the strata server
mcp_tools = klavis_client.mcp_server.list_tools(
    server_url=mcp_server_url,
    format=ToolFormat.OPENAI,
)

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": user_message}
]

response = fireworks_client.chat.completions.create(
    model="accounts/fireworks/models/llama-v3p1-70b-instruct",
    messages=messages,
    tools=mcp_tools.tools
)

import Fireworks from 'fireworks-ai';
import { KlavisClient, Klavis } from 'klavis';

// Initialize clients
const fireworks = new Fireworks({ apiKey: process.env.FIREWORKS_API_KEY });
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });

const userMessage = "Your query here";

// Create strata server with all MCP servers
const strataResponse = await klavisClient.mcpServer.createStrataServer({
    servers: [Klavis.McpServerName.FirecrawlDeepResearch, Klavis.McpServerName.FirecrawlWebSearch, Klavis.McpServerName.Plai],
    userId: "1234"
});

const mcpServerUrl = strataResponse.strataServerUrl;

// Get tools from the strata server
const mcpTools = await klavisClient.mcpServer.listTools({
    serverUrl: mcpServerUrl,
    format: Klavis.ToolFormat.Openai,
});

const response = await fireworks.chat.completions.create({
    model: "accounts/fireworks/models/llama-v3p1-70b-instruct",
    messages: [
        { role: "system", content: "You are a helpful assistant." },
        { role: "user", content: userMessage }
    ],
    tools: mcpTools.tools,
});

Code Examples for together-ai

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

user_message = "Your query here"

# Create strata server with all MCP servers
response = klavis_client.mcp_server.create_strata_server(
    servers=[McpServerName.FIRECRAWL_DEEP_RESEARCH, McpServerName.FIRECRAWL_WEB_SEARCH, McpServerName.PLAI],
    user_id="1234"
)

mcp_server_url = response.strata_server_url

# Get tools from the strata server
mcp_tools = klavis_client.mcp_server.list_tools(
    server_url=mcp_server_url,
    format=ToolFormat.OPENAI,
)

messages = [
    {"role": "system", "content": "You are a helpful AI assistant with access to various tools."},
    {"role": "user", "content": user_message}
]

response = together_client.chat.completions.create(
    model="meta-llama/Llama-2-70b-chat-hf",
    messages=messages,
    tools=mcp_tools.tools
)

import Together from 'together-ai';
import { KlavisClient, Klavis } from 'klavis';

// Initialize clients
const togetherClient = new Together({ apiKey: process.env.TOGETHER_API_KEY });
const klavisClient = new KlavisClient({ apiKey: process.env.KLAVIS_API_KEY });

const userMessage = "Your query here";

// Create strata server with all MCP servers
const strataResponse = await klavisClient.mcpServer.createStrataServer({
    servers: [Klavis.McpServerName.FirecrawlDeepResearch, Klavis.McpServerName.FirecrawlWebSearch, Klavis.McpServerName.Plai],
    userId: "1234"
});

const mcpServerUrl = strataResponse.strataServerUrl;

// Get tools from the strata server
const mcpTools = await klavisClient.mcpServer.listTools({
    serverUrl: mcpServerUrl,
    format: Klavis.ToolFormat.Openai,
});

const response = await togetherClient.chat.completions.create({
    model: "meta-llama/Llama-2-70b-chat-hf",
    messages: [
        { role: "system", content: "You are a helpful AI assistant with access to various tools." },
        { role: "user", content: userMessage }
    ],
    tools: mcpTools.tools,
});

Frequently Asked Questions

Everything you need to know about connecting to these MCP servers

Ready to Get Started?

Join developers who are already using KlavisAI to power their AI agents and AI applications with these MCP servers.

Start For Free

ConnectCrewAIto Firecrawl Deep Research, Firecrawl Web Search, Plai MCP Servers

Firecrawl Deep Research

Available Tools:

Firecrawl Web Search

Available Tools:

Plai

Available Tools:

Connect Using Klavis UI

Navigate to Klavis Home

Authorize Your Servers

Add to Your AI Client

Connect Using API

Get Your API Key

Configure Connections

Test & Deploy

Integrate in minutes, Scale to millions

Frequently Asked Questions

Ready to Get Started?

Connectto Firecrawl Deep Research, Firecrawl Web Search, Plai MCP Servers