Most developers are still copy-pasting code into ChatGPT and hoping for the best. Meanwhile, MCP (Model Context Protocol) lets your AI assistant directly interact with your tools, repos, browsers, and docs - no copy-paste needed.
Here are the 5 MCP servers I actually use and think every developer should have in their setup.
1. Serena - Semantic Code Understanding
This is the one that changed how I think about AI-assisted coding. Most AI tools treat your code as raw text. Serena combines MCP with Language Server Protocol to give the AI actual symbol-level understanding - it knows the relationships between functions, classes, and variables across your entire project.
Why it matters:
Instead of clumsy find-and-replace across files, the AI can use operations like find_symbol, insert_after_symbol, and navigate call hierarchies. It supports 20+ languages including Python, TypeScript, Rust, Go, Java, C#, and more.
The project memory system is a nice touch too - Serena stores knowledge in .serena/memories/ and learns your codebase over time through automatic onboarding.
Setup:
pip install serena-mcpFor Claude Code, add this to ~/.config/claude-code/mcp.json:
{
"mcpServers": {
"serena": {
"command": "uvx",
"args": ["--from", "git+https://github.com/oraios/serena", "serena-mcp-server"]
}
}
}You get two modes - Lite for focused tasks and Standard for the full tool suite. There’s even a web dashboard at localhost:24282 for monitoring.
2. GitHub MCP Server - Git Workflow on Autopilot
The official GitHub MCP server (16k+ stars) lets you manage repos, issues, PRs, and branches through natural language. No more context-switching between your editor and the GitHub UI.
What you can actually do:
- Create repos, branches, and PRs conversationally
- File issues and link them to branches
- Search code across repositories
- Trigger and monitor GitHub Actions workflows
The real power shows up when you chain operations. “Create a feature branch for the auth refactor, open an issue tracking the work, and link them” - one prompt, all handled.
Setup:
npm install @modelcontextprotocol/server-githubFor Claude Code:
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "your_token_here"
}
}
}
}Generate your token at GitHub Settings > Developer settings > Personal access tokens. Give it repo and issue permissions at minimum.
3. Playwright MCP Server - AI-Driven Browser Testing
12.8k+ stars and built into GitHub Copilot’s coding agent. Playwright MCP gives your AI full browser control - navigate, click, type, screenshot, and validate UI across Chromium, Firefox, and WebKit.
The killer feature:
The closed feedback loop. Your AI writes code, launches a browser, interacts with the UI it just built, captures a screenshot, and verifies the result - all without you touching anything. Self-verifying development.
Practical example:
You just built a checkout flow. Instead of manually clicking through it, you tell the AI “test the checkout with a valid card and verify the confirmation page.” It runs the whole sequence and reports back with screenshots.
Setup:
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-playwright"]
}
}
}Works with Claude Desktop, Cursor, and VS Code out of the box.
4. Context7 - Real-Time Docs That Don’t Hallucinate
This one solves a problem every developer has hit - you ask your AI about an API, and it confidently tells you about methods that don’t exist in your version. Context7 dynamically fetches the latest, version-specific documentation and injects it directly into AI prompts.
How it works:
Add “use context7” to your prompt. That’s it. The AI gets current official docs for whatever library you’re working with instead of relying on potentially outdated training data.
So instead of wondering “does Next.js 14.2 handle Server Components this way?” and getting a hallucinated answer, you get version-accurate implementation guidance pulled from the actual docs.
Setup:
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp"]
}
}
}5. Memory MCP Server - Context That Survives Sessions
If you’ve ever had to re-explain your entire project setup to an AI after closing a session, this one’s for you. The Memory MCP server gives your AI persistent, searchable memory across sessions.
What it stores:
Architectural decisions, naming conventions, tech stack preferences, project constraints - anything you’d normally have to repeat. The AI autonomously saves important context and retrieves it when relevant.
Why it matters for real projects:
Multi-week refactors become manageable. The AI remembers that you’re using dependency injection with Inversify, following a specific service naming pattern, and avoiding certain legacy APIs. No re-explaining.
Memories are stored locally so your data stays on your machine.
Setup:
{
"mcpServers": {
"memory": {
"command": "npx",
"args": ["-y", "mcp-memory-keeper"]
}
}
}Why These Five
Each one covers a different gap in AI-assisted development:
- Serena - the AI understands your code structurally, not just as text
- GitHub - version control and collaboration without leaving the editor
- Playwright - automated testing with visual verification
- Context7 - accurate, current documentation instead of hallucinations
- Memory - project context that doesn’t reset every session
Together they turn AI from a fancy autocomplete into something that actually knows your codebase, your tools, and your project history. Pick one, set it up in 10 minutes, and see the difference.
ciao