You use AI for coding. You ask it questions, paste error logs, maybe let it write a function or two. It answers based on what it knows — which is whatever it learned during training, frozen in time like a mammoth in ice. It can't check your database. It can't open your GitHub. It can't Google whether that library you're about to install has been abandoned since 2023. Your AI lives in a box. 😼
The box is the problem. An AI that can't touch your actual infrastructure is just a very eloquent rubber duck.
That changed in November 2024 when Anthropic released MCP (Model Context Protocol) — a standard way for AI tools to connect to external services. Think of it like USB ports for your AI: plug in a "server" (a small background program), and suddenly your AI agent can query databases, manage GitHub issues, search the web, or control a browser. As of March 2026, the official MCP server registry lists thousands of these plugins. Most are demos. Some are broken. Five actually matter for daily work.
I'm going to walk you through each one, with install instructions you can copy-paste in under five minutes.
Before you start: where MCP configs live
MCP servers work with any MCP-compatible client — Claude Code, Claude Desktop, Cursor, Windsurf, Cline. I'll use Claude Code examples, but the config format is nearly identical everywhere.
Your config file lives here:
# Claude Code (project-level)
.mcp.json
# Claude Code (global)
~/.claude.json
# Claude Desktop
~/Library/Application Support/Claude/claude_desktop_config.json # macOS
~/.config/Claude/claude_desktop_config.json # Linux
Every server follows the same pattern:
{
"mcpServers": {
"server-name": {
"command": "npx",
"args": ["-y", "@package/server-name"],
"env": {
"API_KEY": "your-key-here"
}
}
}
}
npx runs a Node.js package without installing it globally. The -y flag skips the confirmation prompt. That's all the ceremony required. Now the good stuff.
1. PostgreSQL — talk to your database in plain English
What it does: Your AI reads your database schema (the structure — tables, columns, types), runs SQL queries (the language databases speak), and returns real results. No more copying output from your terminal and pasting it into chat.
Why you care: Half of development is "check the database, understand the data, write a query." This server turns that into a conversation.
Config:
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": [
"-y", "@modelcontextprotocol/server-postgres",
"postgresql://user:pass@localhost:5432/mydb"
]
}
}
}
You say: "Show me all users who signed up this week but never purchased anything." Claude runs real SQL against your database. Real data comes back. You say: "Create an index to speed that up." Claude analyzes the execution plan and builds the right index.
The server exposes three tools: query (run read-only SQL), list_tables, and describe_table.
Security: Create a read-only database user. Don't hand your admin credentials to any automated tool:
CREATE USER mcp_readonly WITH PASSWORD 'secure_password';
GRANT CONNECT ON DATABASE mydb TO mcp_readonly;
GRANT USAGE ON SCHEMA public TO mcp_readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO mcp_readonly;
Verdict: First server I install on every project. Saves 30+ minutes daily of copy-paste archaeology. 😸
2. GitHub — repos without the browser
What it does: Full GitHub integration — issues, pull requests (PRs — proposed code changes), code search, file operations. All through your AI agent.
Why you care: Context-switching between terminal, chat, and GitHub kills focus. This server keeps you in one place.
Config:
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
}
}
}
}
You need a personal access token — get one at github.com/settings/tokens. Scopes needed: repo, read:org, read:user.
Now you can say: "Create an issue for the login timeout bug with the stack trace I just showed you." Or: "Review PR #47 and comment on security issues." Claude reads the diff, analyzes the code, posts real review comments on GitHub.
Key tools: create_issue, list_pull_requests, search_code, create_branch, get_file_contents. Over a dozen in total.
Power move: Combine this with the Postgres server. "Check the error logs in the database, find the relevant code on GitHub, create an issue with both." One prompt. Three tools. Zero browser tabs. 😹
Verdict: Second server I install. GitHub's web UI is fine for browsing. For working, this is faster.
3. Filesystem — controlled file access with guardrails
What it does: Gives your AI agent access to read, write, search, and manage files — but only inside directories you explicitly allow. It can't wander into your SSH keys or .env files.
Config:
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y", "@modelcontextprotocol/server-filesystem",
"/home/user/projects",
"/home/user/documents"
]
}
}
}
List multiple directories — the server restricts access to only those paths. The server blocks path traversal attempts (tricks like ../../etc/passwd).
Tools: read_file, write_file, create_directory, list_directory, move_file, search_files, read_multiple_files.
Who needs it: Claude Desktop users, mainly. Claude Code already has built-in filesystem access, so this server is redundant there. But for Claude Desktop — where the AI otherwise can't touch your files at all — this is essential. The directory sandboxing (restricting access to specific folders) is a genuinely good security feature.
Verdict: Skip it if you use Claude Code. Install it immediately if you use Claude Desktop.
4. Brave Search — real-time web data
What it does: Web search through the Brave Search API. Your AI looks things up live instead of guessing from training data.
Why you care: "What's the current price of Hetzner CAX11?" "Is this library still maintained?" "What's the latest Next.js version?" These questions need live answers. Training data doesn't know what happened last Tuesday.
Config:
{
"mcpServers": {
"brave-search": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-brave-search"],
"env": {
"BRAVE_API_KEY": "BSA_your_key_here"
}
}
}
}
Get a free API key at brave.com/search/api. Free tier: 2,000 queries/month, 1 request/second. For a solo developer, that's more than enough. Paid tier starts at $5/month for 20,000 queries if you burn through the free limit.
Two tools: brave_web_search (general web search with pagination) and brave_local_search (local business search).
Smart usage: Validate your AI's architecture suggestions before committing. "Search for known issues with Prisma 6.x and PostgreSQL 17" is a great sanity check before you're three days into an implementation.
Verdict: Fills the single biggest gap in AI coding — the inability to check what's true right now. 😼
5. Puppeteer — browser automation through conversation
What it does: Controls a headless browser (a Chromium browser that runs invisibly, without a visible window). Your AI navigates pages, takes screenshots, clicks buttons, fills forms, extracts content from JavaScript-rendered sites.
Config:
{
"mcpServers": {
"puppeteer": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-puppeteer"]
}
}
}
No API keys. No configuration. Puppeteer downloads Chromium automatically.
Tools: puppeteer_navigate, puppeteer_screenshot, puppeteer_click, puppeteer_fill, puppeteer_evaluate (run JavaScript in the page).
Say: "Go to localhost:3000, screenshot the login page, tell me if it renders correctly." Then: "Fill in test credentials and submit." Claude navigates, fills fields, clicks submit, screenshots the result.
I use this for visual regression testing — "Navigate to each route and screenshot it" gives me a visual snapshot Claude can compare against expected layouts. No Playwright setup, no test framework. Just "go look at the page."
Watch out: This runs a real browser. Each instance eats 200-500MB of RAM. Don't leave it running on a memory-constrained laptop. The server cleans up automatically when you close your MCP client.
Verdict: The most fun server on this list. Browser automation through natural language is genuinely satisfying. Essential for frontend work and web scraping. 😸
The complete config — copy and paste this
All five servers, one file:
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres",
"postgresql://mcp_readonly:password@localhost:5432/mydb"]
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxx"
}
},
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem",
"/home/user/projects"]
},
"brave-search": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-brave-search"],
"env": {
"BRAVE_API_KEY": "BSA_xxx"
}
},
"puppeteer": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-puppeteer"]
}
}
}
Replace the placeholder values with your actual credentials. Save to .mcp.json in your project root or ~/.claude.json for global access.
Finding more (and knowing when to stop)
The official registry lives at github.com/modelcontextprotocol/servers. mcpservers.org lists community servers. Browse if you're curious.
But resist the urge to install 15 servers "just in case." Each one is a running process. Each one adds startup time. Each one is an attack surface — a potential entry point for security issues. 80% of developers need two or three servers, tops.
You're dangerous now
You started with an AI that lived in a text box. Now you've got one that queries your database, manages your GitHub, searches the live web, and drives a browser. The protocol underneath — JSON-RPC (a simple message format) over stdio (standard input/output, how programs talk to each other) — is boring. Boring protocols that work are exactly what we needed.
These five servers cover 90% of what a solo developer needs. Everything else in the MCP directory is either niche tooling for specific use cases or a demo that'll break the moment you actually depend on it. Start with Postgres and GitHub. Add Brave Search when you need live data. Add Puppeteer when you want to feel like you're living in 2030.
The box is open. Your AI has hands now. Try not to let it drop anything important. 😹
