docs/usage/community/mcp-market.mdx
The Model Context Protocol (MCP) is an open standard that connects Agents to external tools, data sources, and services. Think of it as a universal adapter — your Agents can interact with databases, APIs, file systems, development tools, business applications, and virtually any external service.
The LobeHub MCP Marketplace brings together high-quality MCPs from creators worldwide, with 10,000+ tools ready to extend your Agents.
Traditional Agents are limited — they can only chat, and they can't interact with your tools or access real-time data. MCP breaks down these barriers:
| Before MCP | With MCP |
|---|---|
| Isolated chatbots | Connected teammates |
| Static knowledge only | Real-time data access |
| Manual copy/paste between tools | Direct action on external systems |
| Each tool needs custom integration | One protocol for thousands of services |
MCP transforms Agents from isolated chatbots into connected teammates that can actually do work.
An MCP server is a program that exposes tools and resources:
LobeHub acts as an MCP client:
When an agent needs external capabilities:
MCP supports two connection methods:
<AccordionGroup> <Accordion title="STDIO (Standard Input/Output)"> **How it works**: MCP server runs as a local process, communicates via stdin/stdout**Use cases**:
- Local tools and scripts
- Desktop applications
- File system access
- Development tools
**Example**:
```json
{
"type": "stdio",
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/workspace"]
}
```
**Use cases**:
- Cloud services
- Remote APIs
- Multi-user tools
- Web applications
**Example**:
```json
{
"type": "http",
"url": "https://api.example.com/mcp",
"headers": {
"Authorization": "Bearer YOUR_API_TOKEN"
}
}
```
MCP supports multiple authentication methods:
<AccordionGroup> <Accordion title="None (public access)"> No authentication required — suitable for public data sources. </Accordion> <Accordion title="Bearer Token"> Simple token-based authentication:```json
{
"auth": {
"type": "bearer",
"token": "your-api-token"
}
}
```
```json
{
"auth": {
"type": "oauth2",
"accessToken": "obtained-from-oauth-flow"
}
}
```
```json
{
"headers": {
"X-API-Key": "your-api-key",
"X-Custom-Auth": "custom-value"
}
}
```
Click on "Community" → "MCP" in the left sidebar to access the MCP Marketplace homepage.
The marketplace is organized by category, making it easy to quickly find the type of MCP you need:
<Callout type={'info'}>Please exercise caution when using MCPs from unknown sources. LobeHub cannot guarantee the safety of all MCPs.</Callout>
The LobeHub Desktop application provides the easiest way to install MCP plugins:
<Steps> ### Find Plugin in MarketplaceBrowse or search for the plugin you need.
LobeHub automatically checks system dependencies and identifies configuration requirements.
If system dependencies are missing, LobeHub provides installation commands for your OS.
Provide required settings: API keys or tokens, connection URLs, authentication credentials, and custom parameters.
LobeHub verifies the server is reachable, authentication works, and tools are available.
Choose which agents can use the MCP plugin. </Steps>
For self-hosted deployments, install MCP servers by configuring your connection settings.
Example: STDIO server (local process)
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/workspace"],
"type": "stdio"
}
}
}
Example: HTTP server (remote service)
{
"mcpServers": {
"github": {
"url": "https://mcp-server-github.example.com",
"type": "http",
"headers": {
"Authorization": "Bearer YOUR_GITHUB_TOKEN"
}
}
}
}
Read, write, search, and manage files in specified directories.
npm install -g @modelcontextprotocol/server-filesystem
Use cases: code review, documentation search, log analysis, project file management.
Interact with repositories, issues, pull requests, and GitHub workflows. Requires a GitHub personal access token.
Use cases: project management, code review automation, issue triage, release management.
Query PostgreSQL, MySQL, and other databases. Analyze schemas, generate reports, explain query plans.
Use cases: data analysis, schema exploration, report generation.
Real-time web search, news, and fact verification via Brave Search, Google Search, and others.
Use cases: up-to-date information, research, news monitoring, competitive analysis.
Send messages, read conversation history, search messages, and manage notifications.
Use cases: team notifications, automated reporting, incident management.
Once installed, MCP plugins automatically expose their tools to your agents. Agents select and invoke tools as needed during conversation:
You: Search my project files for the authentication code
Agent: I'll search your files now.
[Uses filesystem MCP — executes search tool]
Agent: I found authentication-related code in src/auth/login.ts and
src/middleware/auth.ts. Here's what I found...
You can enable Chain of Thought to see exactly which MCP tools are being called and what parameters are used.
Combine multiple MCP tools in sequences:
<Steps> ### User Request"Analyze the GitHub issues from last week and create a summary document"
Fetches issues created in the past 7 days
Analyzes issues, categorizes, identifies patterns
Creates summary document with findings </Steps>
Build your own MCP server to:
An MCP server provides:
<AccordionGroup> <Accordion title="Tools (Functions)"> Callable functions agents can execute:```typescript
{
name: "create_ticket",
description: "Create a new support ticket",
parameters: {
title: { type: "string", required: true },
description: { type: "string", required: true },
priority: { type: "string", enum: ["low", "medium", "high"] }
}
}
```
```typescript
{
uri: "database://tickets/recent",
name: "Recent Tickets",
description: "Tickets from the last 7 days",
mimeType: "application/json"
}
```
```typescript
{
name: "analyze_ticket",
description: "Analyze a support ticket",
arguments: [{ name: "ticket_id", required: true }]
}
```
You can add any MCP-compatible server directly to LobeHub without going through the marketplace. See the Custom MCP guide for a step-by-step walkthrough, or the Skill Management guide for an overview of all skill types.
Use environment variables for sensitive configuration:
{
"type": "stdio",
"command": "python",
"args": ["mcp_server.py"],
"env": {
"API_KEY": "${MCP_API_KEY}",
"DATABASE_URL": "${MCP_DATABASE_URL}"
}
}
Agents can subscribe to resource changes — when new data appears, the agent is notified and can process it immediately.
- Approved servers only
- Review before first connection
- Revoke access anytime
- Enable/disable specific tools
- Read-only vs. read-write access
- Require approval for destructive operations
- Limit to specific directories/databases
- Restrict sensitive data
- Audit access logs
"Show me open pull requests"
"Review the code in src/components/"
Analyzes code quality, suggests improvements
"Add review comments to PR #123" </Steps>
"How many support tickets are unresolved?"
"Send summary to #support channel"
"Create a ticket analysis report" </Steps>
"Find all blog post drafts from last month"
Reviews drafts, suggests edits
"Save edited versions locally" </Steps>
- Verify command exists: `which npx` or `which python`
- Check file paths are absolute
- Ensure dependencies are installed
**HTTP servers**:
- Verify URL is reachable
- Check authentication credentials
- Review CORS settings
For self-hosted deployments, configure MCP behavior with environment variables:
# Plugin timeout (milliseconds)
MCP_TOOL_TIMEOUT=30000
# Enable MCP debug logging
DEBUG_MCP=1
# MCP configuration file path
MCP_CONFIG=/path/to/mcp-config.json
<Card href={'/docs/usage/agent/chain-of-thought'} title={'Chain of Thought'} />
<Card href={'/docs/usage/getting-started/agent'} title={'Agent'} /> </Cards>