How do I use multiple MCP servers (Doc2markdown, Discord, Figma) with LangChain?

LangChain's MultiServerMCPClient supports connecting to multiple MCP servers simultaneously. You can configure each Doc2markdown, Discord, Figma server independently and use their tools together in your LangChain applications. This enables powerful multi-source agent systems where your LangChain agents can query data from Doc2markdown, Discord, Figma and combine insights for comprehensive responses. Klavis AI simplifies multi-server management with centralized configuration and unified connection handling for LangChain applications.

What are the benefits of using Doc2markdown and Discord and Figma together in LangChain?

Combining Doc2markdown and Discord and Figma in your LangChain applications creates powerful synergies for advanced agent workflows. Each service brings unique data sources and capabilities that complement each other, enabling comprehensive knowledge retrieval, cross-platform data correlation, and enhanced AI responses with multi-source validation through LangChain's flexible framework.

Do I need special LangChain packages for MCP server integration?

Yes, you'll need the LangChain MCP adapters package (@langchain/mcp-adapters for TypeScript, langchain-mcp-adapters for Python) and any service-specific packages for the MCP servers you want to connect to. Klavis AI provides detailed package requirements and automated installation scripts for each supported MCP server, along with LangChain-specific configuration examples and troubleshooting guides to ensure smooth setup.

Can I use MCP servers with LangChain agents and LangGraph?

Absolutely! MCP servers are designed to work seamlessly with LangChain's agent framework and LangGraph workflows. You can incorporate MCP server tools into your LangChain agents, use them in LangGraph nodes, and leverage them in complex workflow orchestrations. This allows your agents to perform actions and retrieve data from external services as part of their reasoning and response generation process.

How do I handle authentication for MCP servers in LangChain?

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

Can I use these MCP servers in LangChain chains and workflows?

Yes, you can use these MCP servers as data sources and action providers in LangChain chains and workflows. This allows you to create comprehensive AI applications that include both internal logic and real-time external data access. Klavis AI provides optimized workflow patterns and processing pipelines specifically designed for MCP server integration with LangChain's chain and workflow systems.

What types of LangChain applications benefit most from MCP server integration?

LangChain applications that benefit most include: conversational agents needing real-time data access, automated workflow systems requiring integration with multiple platforms, research and analysis tools that need to pull data from various sources, and AI agents that perform complex multi-step workflows across multiple services. MCP servers extend LangChain beyond static processing to dynamic, real-time AI applications with external service integration.

How does MCP server integration affect LangChain performance?

MCP server integration adds network latency for external API calls, but the impact is typically minimal when properly configured. LangChain's asynchronous capabilities and parallel tool execution help manage multiple MCP server calls efficiently. Best practices include caching frequently accessed data, using appropriate timeouts, implementing fallback strategies, and leveraging LangChain's streaming capabilities for real-time responses. Klavis AI provides performance monitoring tools and optimization recommendations to ensure your LangChain + MCP server applications run at peak efficiency.

Can I use MCP servers with LangChain streaming and async operations?

Yes, MCP servers work excellently with LangChain's streaming and async capabilities. You can stream responses from MCP server tools, run multiple MCP server calls in parallel, and integrate MCP server operations into async LangChain workflows. This enables responsive AI applications that can provide real-time updates and handle multiple concurrent operations efficiently.

Why choose Klavis AI for LangChain MCP server connections?

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

Connectto Doc2markdown, Discord, Figma MCP Servers

Create powerful AI workflows by connecting multiple MCP servers including Doc2markdown, Discord, Figma for enhanced automation capabilities in Klavis AI.

Get Started Free View All MCP Servers

Doc2markdown

featured

Convert any file to markdown using markitdown

Available Tools:

convert_document_to_markdown

Discord

featured

Discord is a VoIP and instant messaging social platform

Available Tools:

discord_get_server_info
discord_list_members
discord_create_text_channel
+6 more tools

Figma

featured

Figma is a collaborative interface design tool for web and mobile applications.

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
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.DOC2MARKDOWN, McpServerName.DISCORD, McpServerName.FIGMA],
    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"}]
}))

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.DOC2MARKDOWN, McpServerName.DISCORD, McpServerName.FIGMA],
    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.Doc2markdown, Klavis.McpServerName.Discord, Klavis.McpServerName.Figma],
    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.DOC2MARKDOWN, McpServerName.DISCORD, McpServerName.FIGMA],
    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.Doc2markdown, Klavis.McpServerName.Discord, Klavis.McpServerName.Figma],
    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.DOC2MARKDOWN, McpServerName.DISCORD, McpServerName.FIGMA],
    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.Doc2markdown, Klavis.McpServerName.Discord, Klavis.McpServerName.Figma],
    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 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.DOC2MARKDOWN, McpServerName.DISCORD, McpServerName.FIGMA],
    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.Doc2markdown, Klavis.McpServerName.Discord, Klavis.McpServerName.Figma],
    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 crewai

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.DOC2MARKDOWN, McpServerName.DISCORD, McpServerName.FIGMA],
    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()

// CrewAI currently only supports Python. Please use the Python example.

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.DOC2MARKDOWN, McpServerName.DISCORD, McpServerName.FIGMA],
    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.Doc2markdown, Klavis.McpServerName.Discord, Klavis.McpServerName.Figma],
    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.DOC2MARKDOWN, McpServerName.DISCORD, McpServerName.FIGMA],
    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.Doc2markdown, Klavis.McpServerName.Discord, Klavis.McpServerName.Figma],
    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

ConnectLangChainto Doc2markdown, Discord, Figma MCP Servers

Doc2markdown

Available Tools:

Discord

Available Tools:

Figma

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 Doc2markdown, Discord, Figma MCP Servers